soc-2008-mxcurioni: merged changes to revision 14747, cosmetic changes for source/blender/freestyle

300 files changed, 177801 insertions, 0 deletions

diff --git a/source/blender/freestyle/intern/AUTHORS.TXT b/source/blender/freestyle/intern/AUTHORS.TXT
new file mode 100755
index 00000000000..27cdb70d5ec
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/BUGS.TXT b/source/blender/freestyle/intern/BUGS.TXT
new file mode 100755
index 00000000000..c5bad029a47
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/CHANGELOG.TXT b/source/blender/freestyle/intern/CHANGELOG.TXT
new file mode 100755
index 00000000000..cb9f088bc1f
--- /dev/null
+++ b/source/blender/freestyle/intern/CHANGELOG.TXT
@@ -0,0 +1,47 @@
+2008-03-06 - freestyle-2.2.0
+	* Fixed a bug related to the ViewShape IDs that caused the ray casting to crash.
+	* Fixed a bug in the style module insertion.
+                
+2008-03-02 - freestyle-2.1.1
+	* Added the management of texture coordinates in the scene graph and the rendering.
+	* The reps in the scene graph are now assigned ids based on the lib3ds nodes ids. These ids are transmitted to the WingedEdge Shapes.
+2007-10-05 - freestyle-2.0.1
+
+	* Enforced node construction from lib3ds (thanks to Thomas Netter)
+        * Reverted to not using bundles by default on MacOSX. Activating bundles can be made by uncommenting the lib_bundle line of the CONFIG variable in Config.pri
+        * Added a NodeCamera to the scene graph.
+        * Made sure the display lists were compiled AND executed (GL_COMPILE -> GL_COMPILE_AND_EXECUTE) for IndexedFaceSet.
+        * Added a visitor to deallocate memory on the graphics card (display lists right now).
+        * Modified the grid to use a visitor pattern for ray casting and grid traversal.
+        
+
+
+2007-05-06 - freestyle-2.0.0
+
+	* Switched to Qt 4.2.3, swig 1.3.31, visual c++ 2005, gcc 4.0.1, qglviewer 2.2.5-1
+	* Added texture coordinates to scene graph
+	* Made the grid more robust
+        * Now compiles on MacOSX
+        * Fixed the brush texture problem: the full path to the texture was used instead of the base name and that was breaking the search path algorithm
+
+
+2006-06-18 - freestyle-1.0.2
+
+	* Fixed a bug related to the loading of OpenGL extensions.
+
+
+2005-07-25 - freestyle-1.0.1
+
+	* Upgrade to QGLViewer 2.0.4
+	* Added the FREESTYLE_DIR environment variable.
+	  It must be set to the freestyle directory for
+	  all releases except the pre-compiled windows version.
+	* Fixed the unix path separator.
+	* Added the "Help>Control bindings" menu action.
+	* Fixed the style modules according to Python 2.4 standards.
+
+
+2005-04-05 - freestyle-1.0.0  
+
+	* Initial release
+
diff --git a/source/blender/freestyle/intern/COPYRIGHT.TXT b/source/blender/freestyle/intern/COPYRIGHT.TXT
new file mode 100755
index 00000000000..cd37bd16786
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/Config.pri b/source/blender/freestyle/intern/Config.pri
new file mode 100755
index 00000000000..68763dba502
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/Freestyle-vc7-debug.sln b/source/blender/freestyle/intern/Freestyle-vc7-debug.sln
new file mode 100755
index 00000000000..937f3f9faf9
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/Freestyle-vc7-release.sln b/source/blender/freestyle/intern/Freestyle-vc7-release.sln
new file mode 100755
index 00000000000..74d5dc77f86
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/Freestyle-vc8-debug.sln b/source/blender/freestyle/intern/Freestyle-vc8-debug.sln
new file mode 100755
index 00000000000..097ca30a174
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/Freestyle-vc8-release.sln b/source/blender/freestyle/intern/Freestyle-vc8-release.sln
new file mode 100755
index 00000000000..82b22ff0c3e
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/INSTALL.TXT b/source/blender/freestyle/intern/INSTALL.TXT
new file mode 100755
index 00000000000..4fab1275116
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/LICENSE.TXT b/source/blender/freestyle/intern/LICENSE.TXT
new file mode 100755
index 00000000000..5b6e7c66c27
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/Makefile.pro b/source/blender/freestyle/intern/Makefile.pro
new file mode 100755
index 00000000000..0e64bb342c3
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/README.TXT b/source/blender/freestyle/intern/README.TXT
new file mode 100755
index 00000000000..b0d026c8b9b
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/THANKS.TXT b/source/blender/freestyle/intern/THANKS.TXT
new file mode 100755
index 00000000000..3147715a63f
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/TODO.TXT b/source/blender/freestyle/intern/TODO.TXT
new file mode 100755
index 00000000000..2e24752e026
--- /dev/null
+++ b/source/blender/freestyle/intern/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/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..60d36880c12
--- /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..703970c0fb1
--- /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..fe2ae994f77
--- /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..d7091440e06
--- /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..0915a4c3cbd
--- /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..c0bb8b4109c
--- /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..d59ad716c18
--- /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..24bb2c7229b
--- /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..03b4f3a28ea
--- /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..ac41b31ac78
--- /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..ae4d28017c5
--- /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..44b5e0de224
--- /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/build_bundle.macosx.py b/source/blender/freestyle/intern/build_bundle.macosx.py
new file mode 100755
index 00000000000..e97153f269c
--- /dev/null
+++ b/source/blender/freestyle/intern/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/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..d78d90ccb4a
--- /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..59b730358bc
--- /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());
+    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;
+    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]);
+    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]);
+          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;
+            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..6197721bb45
--- /dev/null
+++ b/source/blender/freestyle/intern/geometry/Grid.h
@@ -0,0 +1,358 @@
+//
+//  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 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 {
+public:
+      firstIntersectionGridVisitor(const Vec3r& ray_org, const Vec3r& ray_dir, const Vec3r& cell_size) : 
+      GridVisitor(), ray_org_(ray_org), cell_size_(cell_size),ray_dir_(ray_dir),occluder_(0),
+            u_(0),v_(0),t_(DBL_MAX),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_;}
+    
+public:
+    double u_, v_, t_;
+private:
+    Polygon3r *occluder_;
+    Vec3r ray_org_, ray_dir_;
+    Vec3r cell_size_;
+    Cell * current_cell_;
+};
+
+//
+// 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..97c2aedc62e
--- /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..c75177541d3
--- /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;
+  unsigned w=map->width();
+  unsigned h=map->height();
+
+  // 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..45c02004d1c
--- /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);
+  }
+  int i  = 1<<level;
+  int sx = x>>level;
+  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){
+      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/libconfig.pri b/source/blender/freestyle/intern/libconfig.pri
new file mode 100755
index 00000000000..6fec8878694
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/makedsp.vcnet.debug.bat b/source/blender/freestyle/intern/makedsp.vcnet.debug.bat
new file mode 100755
index 00000000000..e19ca52b4f7
--- /dev/null
+++ b/source/blender/freestyle/intern/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/intern/makedsp.vcnet.release.bat b/source/blender/freestyle/intern/makedsp.vcnet.release.bat
new file mode 100755
index 00000000000..3050a2fe4ea
--- /dev/null
+++ b/source/blender/freestyle/intern/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/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..b396a0ce6d3
--- /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++) 
+  {
+    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..abf76d079da
--- /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..d566060dfc7
--- /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();
+  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..7525807da47
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLStrokeRenderer.cpp
@@ -0,0 +1,495 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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 <qimage.h>
+#include <qfileinfo.h>
+#include <qgl.h>
+#include <qfile.h>
+#include "GLStrokeRenderer.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;
+    // }
+  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);
+  Stroke::MediumType strokeType = iStrokeRep->getMediumType();
+  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(int 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++)
+    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;
+  QString path;
+  StringUtils::getPathName(TextureManager::Options::getBrushesPath(),
+  sname,
+  pathnames);
+  for (vector<string>::const_iterator j = pathnames.begin(); j != pathnames.end(); j++) {
+    path = j->c_str();
+    if(QFile::exists(path)){
+      found = true;
+      break;
+    }
+  }
+  if(!found)
+    return 0;
+  // Brush texture
+  cout << "Loading brush texture..." << endl;
+  switch(mediumType){
+  case Stroke::DRY_MEDIUM:
+    prepareTextureLuminance((const char*)path.toAscii(), texId);
+    break;
+  case Stroke::HUMID_MEDIUM:
+  case Stroke::OPAQUE_MEDIUM:
+  default:
+    prepareTextureAlpha((const char*)path.toAscii(), texId);
+    break;
+  }
+  cout << "Done." << endl << endl;
+
+  return texId;
+}
+
+bool 
+GLTextureManager::prepareTextureAlpha (string sname, GLuint itexname)
+{
+  const char * name = sname.c_str();
+  QImage qim(name);
+  QFileInfo fi(name);
+  QString filename = fi.fileName();
+  if (qim.isNull()) 
+    {
+      cerr << "  Error: unable to read \"" << name << "\"" << endl;
+      return false;
+    }
+  if (qim.depth()>8)
+    {
+      cerr<<"  Error: \""<< name <<"\" has "<<qim.depth()<<" bits/pixel"<<endl;
+      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.width(), qim.height(), 0, 
+	       GL_ALPHA, GL_UNSIGNED_BYTE, qim.bits());	
+
+  cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;
+
+  return true;
+
+}
+
+bool 
+GLTextureManager::prepareTextureLuminance (string sname, GLuint itexname)
+{
+  const char * name = sname.c_str();
+  QImage qim(name);
+  QFileInfo fi(name);
+  QString filename = fi.fileName();
+  if (qim.isNull()) 
+    {
+      cerr << "  Error: unable to read \"" << name << "\"" << endl;
+      return false;
+    }
+  if (qim.depth() > 8)
+    {
+      cerr<<"  Error: \""<<name<<"\" has "<<qim.depth()<<" bits/pixel"<<endl;
+      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.width(), qim.height(), 0, 
+	       GL_LUMINANCE, GL_UNSIGNED_BYTE, qim.bits());	
+
+  cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;
+
+  return true;
+
+}
+
+bool 
+GLTextureManager::prepareTextureLuminanceAndAlpha (string sname, GLuint itexname)
+{
+  const char * name = sname.c_str();
+  QImage qim(name);
+  QFileInfo fi(name);
+  QString filename = fi.fileName();
+  if (qim.isNull()) 
+    {
+      cerr << "  Error: unable to read \"" << name << "\"" << endl;
+      return false;
+    }
+  if (qim.depth() > 8)
+    {
+      cerr<<"  Error: \""<<name<<"\" has "<<qim.depth()<<" bits/pixel"<<endl;
+      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.width(), qim.height(), 0, 
+	       GL_LUMINANCE, GL_UNSIGNED_BYTE, qim.bits());	
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, qim.width(), qim.height(), 0, 
+	       GL_ALPHA, GL_UNSIGNED_BYTE, qim.bits());	
+							 
+  cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " bits per pixel" << endl;						   
+
+  return true;
+							     
+}
+
+bool 
+GLTextureManager::preparePaper (const char *name, GLuint itexname)
+{
+  QImage qim(name);
+  QFileInfo fi(name);
+  QString filename = fi.fileName();
+  if (qim.isNull()) 
+    {
+      cerr << "  Error: unable to read \"" << name << "\"" << endl;
+      return false;
+    }
+  if (qim.depth()!=32)
+    {
+      cerr<<"  Error: \""<<name<<"\" has "<<qim.depth()<<" bits/pixel"<<endl;
+      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.width(), qim.height(), 0, 
+	       GL_RGBA, GL_UNSIGNED_BYTE, qim2.bits());	
+
+  cout << "  \"" << filename.toAscii().data() << "\" loaded with "<< qim.depth() << " 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..5e9ba2a5bf4
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLUtils.cpp
@@ -0,0 +1,68 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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;
+#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/GLXOffscreenViewer.cpp b/source/blender/freestyle/intern/rendering/GLXOffscreenViewer.cpp
new file mode 100755
index 00000000000..7135cedd7ad
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLXOffscreenViewer.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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef WIN32
+# include "GLRenderer.h"
+# include "GLXOffscreenViewer.h"
+
+
+GLXOffscreenViewer::GLXOffscreenViewer(int w, int h){
+    _offscreenArea = new OffScreenArea(OffScreenArea::PIXMAP_OFFSCREEN_TYPE);
+    _offscreenArea->AllocateOffScreenArea(w,h);
+    _RootNode.SetLightingEnabled(false);
+    _RootNode.SetLineWidth(1.0);
+    _pGLRenderer = new GLRenderer;
+} 
+
+GLXOffscreenViewer::~GLXOffscreenViewer(){
+    if(_offscreenArea)
+      delete _offscreenArea;
+    if(_pGLRenderer)
+      delete _pGLRenderer;
+    _RootNode.destroy();  
+}
+
+void GLXOffscreenViewer::AddNode(Node* iNode){
+  _RootNode.AddChild(iNode);
+}
+
+void GLXOffscreenViewer::DetachNode(Node* iNode){
+  _RootNode.DetachChild(iNode);
+}
+
+void GLXOffscreenViewer::init(){
+  glClearColor(_clearColor[0],_clearColor[1],_clearColor[2],1);
+}
+
+void GLXOffscreenViewer::readPixels(int x,
+                                int y,
+                                int width,
+                                int height,
+                                float *pixels){
+  _offscreenArea->MakeCurrent();
+  glReadBuffer(GL_FRONT);
+  GLenum glformat = GL_RED;
+  glReadPixels(x,y,width, height, glformat, GL_FLOAT, (GLfloat*)pixels);
+} 
+
+
+
+void GLXOffscreenViewer::draw()
+{
+  _offscreenArea->MakeCurrent();
+  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);
+  glFlush();
+  glPopAttrib();
+}
+
+#endif
diff --git a/source/blender/freestyle/intern/rendering/GLXOffscreenViewer.h b/source/blender/freestyle/intern/rendering/GLXOffscreenViewer.h
new file mode 100755
index 00000000000..c09a23f500b
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/GLXOffscreenViewer.h
@@ -0,0 +1,545 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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 GLXOFFSCREENVIEWER_H
+# define GLXOFFSCREENVIEWER_H
+
+# ifdef 0
+//#ifndef WIN32
+//
+// @(#)OffScreen.h	1.4 10/11/00
+//
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <iostream>
+#include <malloc.h>
+#include <math.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/times.h>
+
+#include <X11/Xlib.h>
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include <GL/glu.h>
+
+namespace OFFSCREEN {	// I put this here to avoid conflicts between Qt and
+								// X11 in the definition of INT32
+
+	/*! \namespace OFFSCREEN
+	 *  \bugs attention a la restauration de context quand il n'avait rien avant l'OffScreenArea !!
+	 */
+
+static bool OutOfMemory = false ;
+static XErrorHandler oldHandler = NULL ;
+
+static int myXErrorHandler (Display *_d, XErrorEvent *_xee)
+{
+	OutOfMemory = True;
+	if(oldHandler)
+	{
+		return (*oldHandler)(_d,_xee);
+	}
+	else
+	{
+		return false;
+	}
+
+	return 0;
+}
+
+class OffScreenArea 
+{
+	public:
+		static const int UNKNOWN_OFFSCREEN_TYPE = 0 ;
+		static const int PIXMAP_OFFSCREEN_TYPE = 1 ;
+		static const int PBUFFER_OFFSCREEN_TYPE = 2 ;
+		static const int KEEP_PIXMAP = 1 ;
+
+		OffScreenArea  (int type = UNKNOWN_OFFSCREEN_TYPE,GLXContext shareCtx = NULL)
+		{
+			DefaultType = type ;
+			i_Screen = -1;
+			i_Height = 0;
+			i_Width  = 0;
+			
+			i_OffScreenAreaType = UNKNOWN_OFFSCREEN_TYPE ;
+			i_GLContext = NULL;
+			i_Drawable  = GLXDrawable(0);
+			i_XPix      = Pixmap(0);
+			i_pXVisual  = NULL;
+			i_pDisplay  = NULL;
+
+			SetDisplayAndScreen((Display *)NULL,(int)-1) ;
+		}
+
+		GLXContext GetGLXContext() { return i_GLContext ; }
+		~OffScreenArea ()
+		{
+			DestroyOffScreenArea();
+		}
+	
+		/*
+		 * 0 : cannot allocate
+		 * 1 : allocation done
+		 * FIRST : try to allocate PixelBuffer (Single, double buffer)
+		 * SECOND : try to allocate GLXPixmap if PixelBuffer is not available
+		 */
+		/*
+		 * Here, we try to allocate an OffScreen Area
+		 * first, with PBuffer (if this GLX_ext. is
+		 * available and we can create one)
+		 * second, with a pixmap 
+		 */
+		int AllocateOffScreenArea(int width,int height)
+		{
+			save_GLContext = glXGetCurrentContext();
+			save_pDisplay  = glXGetCurrentDisplay();
+			save_Drawable  = glXGetCurrentDrawable();
+
+			int AlreadyThere = 0;
+#ifdef A_VIRER
+			static int AlreadyThere = 0;
+
+			if ( ( width != i_Width ) || ( height != i_Height ) )
+			{
+				AlreadyThere = 0;
+				DestroyOffScreenArea();
+			}
+#endif
+			if(!AlreadyThere)
+			{
+				AlreadyThere = 1;
+
+				/** Before to use a Pixmap, we try with pbuffer **/	
+				if(TryPBuffer(false,width,height))
+				{
+#ifdef DEBUG
+					fprintf(stderr, "Using single-buffer PBuffer for off-screen rendering.\n") ;
+#endif
+					return true ;
+				}
+
+				fprintf(stderr, "Cannot use a single-buffer PBuffer, trying double buffer.\n") ;
+
+				if(TryPBuffer(true,width,height))
+				{
+#ifdef DEBUG
+					fprintf(stderr, "Using double-buffer PBuffer for off-screen rendering.\n") ;
+#endif
+					return true ;
+				}
+#ifdef DEBUG
+				fprintf(stderr, "Warning : cannot create a PBuffer, trying Pixmap\n");
+#endif
+				if(TryPixmap(width,height))
+				{
+#ifdef DEBUG
+					fprintf(stderr, "Notice  : using Pixmap for offScreen rendering\n");
+#endif
+					return true ;
+				}
+#ifdef DEBUG
+				fprintf (stderr, "Warning : cannot create a Pixmap\n");
+#endif
+
+				return false;
+			}
+			return true ;
+		}
+
+		void MakeCurrent() 
+		{
+			glXMakeCurrent(i_pDisplay,i_Drawable,i_GLContext);
+		}
+	
+	protected:
+		inline  Display     * XServer         ( void ) { return i_pDisplay; }
+		inline  GLXContext    GraphicContext  ( void ) { return i_GLContext; }
+		inline  GLXDrawable   Drawable        ( void ) { return i_Drawable; }
+		inline  XVisualInfo * XVisual         ( void ) { return i_pXVisual; }
+
+		int DefaultType ;
+		int i_OffScreenAreaType;
+		int i_Height;
+		int i_Width;
+	
+		GLXContext    save_GLContext;
+		Display     * save_pDisplay;
+		GLXDrawable   save_Drawable;
+
+		Display     * i_pDisplay;
+		int           i_Screen;
+		GLXContext    i_GLContext;
+		GLXContext    i_shareContext;
+		GLXDrawable   i_Drawable;
+		Pixmap        i_XPix;
+		XVisualInfo * i_pXVisual;
+	
+		/* 
+		 * Define Display and screen
+		 * IF display == NULL THEN try to open default Display
+		 * IF screenNumber is < 0 THEN take default Screen
+		 */
+		void SetDisplayAndScreen ( Display *pDisplay , int Screen )
+		{
+			if ( pDisplay == NULL )
+			    i_pDisplay = XOpenDisplay ( NULL );
+			else
+			    i_pDisplay = pDisplay;
+			
+			if ( Screen < 0 )
+			    i_Screen = DefaultScreen ( i_pDisplay );
+			else
+			    i_Screen = Screen;
+		}
+		
+		// 
+		// Creates a PBuffer
+		// 
+		// <Return Values>
+		// 0 : failure
+		// 1 : succeed
+		//  
+
+		bool CreatePBuffer (unsigned int width, unsigned int height , int * pAttribList)
+		{
+#ifdef DEBUG	
+			int error = 0 ;
+			while((error = glGetError()) > 0)
+				std::cerr << "GLError " << (void *)error << " encountered." << std::endl ;
+#endif
+			GLXFBConfig *pfbConfigs;
+			int nbConfigs;
+			static int pbAttribs[] = { GLX_LARGEST_PBUFFER, true,
+												GLX_PRESERVED_CONTENTS, true,
+												GLX_PBUFFER_WIDTH,0,
+												GLX_PBUFFER_HEIGHT,0,
+			  									None };
+			
+			pbAttribs[5] = width ;
+			pbAttribs[7] = height ;
+
+			// Looks for a config that matches pAttribList
+			pfbConfigs = glXChooseFBConfig(i_pDisplay,i_Screen,pAttribList,&nbConfigs) ;
+#ifdef DEBUG
+			std::cout << nbConfigs << " found for pbuffer." << std::endl ;
+#endif
+
+			if(pfbConfigs == NULL)
+				return false ;
+
+			i_pXVisual = glXGetVisualFromFBConfig(i_pDisplay,pfbConfigs[0]);
+			i_OffScreenAreaType = PBUFFER_OFFSCREEN_TYPE;
+
+			// Sets current error handler
+			OutOfMemory = False;
+			oldHandler = XSetErrorHandler( myXErrorHandler );
+
+			i_Drawable = glXCreatePbuffer(i_pDisplay,pfbConfigs[0],pbAttribs);
+					
+			if(i_Drawable == 0)
+			{
+				i_pXVisual = NULL;
+				return false ;
+			}
+			unsigned int w=0,h=0;
+			glXQueryDrawable(i_pDisplay,i_Drawable,GLX_WIDTH,&w) ;
+			glXQueryDrawable(i_pDisplay,i_Drawable,GLX_HEIGHT,&h) ;
+
+			if((w != width)||(h != height))
+			{
+#ifdef DEBUG
+				std::cerr << "Could not allocate Pbuffer. Only size " << w << "x" << h << " found." << std::endl ;
+#endif
+				return false ;
+			}
+#ifdef DEBUG
+			else
+				std::cerr << "Could allocate Pbuffer. Size " << w << "x" << h << " found." << std::endl ;
+#endif
+#ifdef DEBUG	
+			while((error = glGetError()) > 0)
+				std::cerr << "GLError " << (void *)error << " encountered." << std::endl ;
+#endif
+			// now create GLXContext
+
+			if((i_GLContext = glXCreateContext(i_pDisplay,i_pXVisual,NULL,true)) == NULL) 
+			{
+				DestroyOffScreenArea() ;
+				return false ;
+			}
+
+			/* Restore original X error handler */
+			(void) XSetErrorHandler( oldHandler );
+		
+			if(!OutOfMemory)
+			{	
+				i_Height = height;
+				i_Width  = width;
+			
+				return true ;
+			}
+			else
+				return false ;
+		}
+
+		// 
+		// Creates a Pixmap
+		// 
+		// <Return Values>
+		// false : failure
+		// true  : succeed
+		// 
+
+		bool CreatePixmap (int width, int height , int * pAttribList)
+		{
+			int depth;
+			int totdepth=0;
+			XErrorHandler oldHandler;
+			XVisualInfo * pvisP;
+			
+			pvisP = glXChooseVisual ( i_pDisplay, i_Screen , pAttribList);
+
+			if ( pvisP == NULL)
+			{
+				fprintf( stderr , "Warning : no 24-bit true color visual available\n" );
+				return false ;
+			}
+			
+			OutOfMemory = False;
+			oldHandler = XSetErrorHandler(myXErrorHandler);
+			if(i_XPix == Pixmap(NULL))
+			{
+				depth = 0;
+				for (unsigned int i=0,j=0; (pAttribList[i] != None) && (j<3) ; i++ )
+				{
+					switch ( pAttribList[i] )
+					{
+						case GLX_RED_SIZE: 	glXGetConfig(i_pDisplay,pvisP,GLX_RED_SIZE,&depth) ;
+													totdepth += depth ;
+													i++ ;
+													j++ ;
+					    							break;
+		
+						case GLX_GREEN_SIZE: glXGetConfig(i_pDisplay,pvisP,GLX_GREEN_SIZE,&depth) ;
+													totdepth += depth ;
+													i++ ;
+													j++ ;
+													break;
+		
+						case GLX_BLUE_SIZE: 	glXGetConfig(i_pDisplay,pvisP,GLX_BLUE_SIZE,&depth) ;
+													totdepth += depth ;
+													i++ ;
+													j++ ;
+													break;
+						default:
+													break;
+					}
+				}
+			    
+				fprintf(stderr,"%d bits color buffer found\n",depth) ;
+				i_XPix = XCreatePixmap(i_pDisplay,RootWindow (i_pDisplay,0),width,height,totdepth);
+				XSync(i_pDisplay,False);
+				if(OutOfMemory)
+				{
+					i_XPix = Pixmap(0);
+					XSetErrorHandler(oldHandler);
+					oldHandler = NULL ;
+					fprintf(stderr,"Warning : could not allocate Pixmap\n");
+					return false ;
+				}
+			}
+		
+			// Perhaps should we verify th type of Area (Pixmap) ?
+			if ( i_Drawable == GLXDrawable(NULL) )
+			{
+				// i_Drawable = i_XPix;
+				i_Drawable = glXCreateGLXPixmap ( i_pDisplay , pvisP , i_XPix );
+				XSync ( i_pDisplay , False );
+				if(OutOfMemory)
+			 	{ 
+					i_Drawable = GLXDrawable(0); 
+					DestroyOffScreenArea();
+					fprintf ( stderr , "Warning : could not allocate GLX Pixmap\n"); 
+					return false ;
+				} 
+				else
+				{
+					if(i_GLContext != NULL) 
+					{
+						glXDestroyContext ( i_pDisplay , i_GLContext );
+						i_GLContext = NULL;
+					}
+					if((i_GLContext = glXCreateContext(i_pDisplay,pvisP,NULL,GL_FALSE)) == NULL)
+					{
+						DestroyOffScreenArea();
+						fprintf(stderr, "Warning : could not create rendering context");
+					}
+				}
+			}
+			XSetErrorHandler(oldHandler);
+			
+			i_pXVisual = (i_Drawable != GLXDrawable(NULL) ? pvisP : NULL);
+			
+			i_Height = height;
+			i_Width  = width;
+			
+			if(i_Drawable != GLXDrawable(NULL))
+			{
+				i_OffScreenAreaType = PIXMAP_OFFSCREEN_TYPE;
+				return true ;
+			}
+			
+			return false ;
+		}
+
+		bool TryPixmap(int width,int height)
+		{
+			int attrList[30];
+			int n = 0;
+		
+			attrList[n++] = GLX_RED_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_GREEN_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_BLUE_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_RGBA;
+			attrList[n++] = GLX_DEPTH_SIZE;
+			attrList[n++] = 16;
+			attrList[n++] = GLX_STENCIL_SIZE;
+			attrList[n++] = 1;
+			attrList[n++] = None;
+		
+			return CreatePixmap(width,height,attrList) ;
+		}
+
+		bool TryPBuffer(bool double_buffer,int width,int height)
+		{
+			int attrList[30];
+			int n = 0;
+		
+			attrList[n++] = GLX_RENDER_TYPE;
+			attrList[n++] = GLX_RGBA_BIT;
+			attrList[n++] = GLX_DRAWABLE_TYPE;
+			attrList[n++] = GLX_PBUFFER_BIT;
+			attrList[n++] = GLX_RED_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_GREEN_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_BLUE_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_DEPTH_SIZE;
+			attrList[n++] = 8;
+			attrList[n++] = GLX_DOUBLEBUFFER;
+			attrList[n++] = double_buffer;
+			attrList[n++] = None;
+		
+			return CreatePBuffer(width,height,attrList) ;
+		}
+
+		void DestroyOffScreenArea()
+		{
+			glXMakeCurrent(save_pDisplay,save_Drawable,save_GLContext);
+
+			switch ( i_OffScreenAreaType )
+			{
+				case PIXMAP_OFFSCREEN_TYPE : 	if(i_Drawable != 0)
+					  										glXDestroyGLXPixmap(i_pDisplay,i_Drawable);
+					
+														if (i_XPix != 0)
+														{
+															XFreePixmap (i_pDisplay,i_XPix);
+															i_XPix = 0;
+														}
+														break;
+			   case PBUFFER_OFFSCREEN_TYPE :	if(i_Drawable != 0)
+															glXDestroyPbuffer(i_pDisplay,i_Drawable);
+		      										break;
+				default: break;
+			}
+		
+			if (i_GLContext != NULL)
+			{
+				glXDestroyContext(i_pDisplay,i_GLContext);
+				i_GLContext = NULL;
+			}
+		  
+			i_Drawable = 0;
+			i_OffScreenAreaType = UNKNOWN_OFFSCREEN_TYPE;
+		}
+} ;
+
+}
+
+
+#include "Geom.h"
+#include "NodeDrawingStyle.h"
+using namespace Geometry;
+//using namespace OFFSCREEN;
+class GLXOffscreenViewer{
+public:
+  GLXOffscreenViewer(int w, int h);
+  virtual ~GLXOffscreenViewer();
+
+  /*! 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) ;
+
+    inline void SetClearColor(const Vec3f& c) {_clearColor = c;}
+    inline Vec3f getClearColor() const {return _clearColor;}
+
+  void init();
+  void draw();
+
+protected:
+  OffScreenArea *_offscreenArea;
+  NodeDrawingStyle       _RootNode;
+  Vec3f           _clearColor;
+  GLRenderer     *_pGLRenderer;
+  
+};
+
+#endif // WIN32
+
+#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..ec73fc52ae4
--- /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..7f11f461b1c
--- /dev/null
+++ b/source/blender/freestyle/intern/rendering/pbuffer.h
@@ -0,0 +1,77 @@
+#ifndef PBUFFERS_H
+#define PBUFFERS_H
+
+#ifndef WIN32
+#  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
+#endif //WIN32
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..e2be6fa8264
--- /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..ec3d3ad748c
--- /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..c6951942dbb
--- /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..9dec2ec803f
--- /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..1bbba130ba3
--- /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..09557ad3473
--- /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..515874c4021
--- /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..ab31e656d46
--- /dev/null
+++ b/source/blender/freestyle/intern/scene_graph/MaxFileLoader.h
@@ -0,0 +1,94 @@
+//
+//  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>
+# 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..1726dd3c853
--- /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..18442ae10f9
--- /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..3e963beec38
--- /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..64e9b7a4dd6
--- /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..3929c60996b
--- /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..6ccc2152c48
--- /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..215124b0676
--- /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..20df12cfd8f
--- /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..1ecb5f141e1
--- /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..9dce7fbbe9c
--- /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..d92575cf110
--- /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..cf2982606e0
--- /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) {
+    unsigned size;
+    double res =  integrate(_fun, inter.pointsBegin(_sampling), inter.pointsEnd(_sampling), _integration);
+    return res;
+  } 
+  
+  double GetCompleteViewMapDensityF1D::operator()(Interface1D& inter) {
+    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..b1c5317c5f1
--- /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..c3827ae3e36
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.cpp
@@ -0,0 +1,1100 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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 <qimage.h>
+#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"
+#include <QString>
+
+// Internal function
+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;
+  }
+}
+
+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;
+    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;
+    QImage image;
+    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.load(j->c_str());
+	break;
+      }
+    }
+    if (image.isNull())
+      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;
+    QImage image;
+    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.load(j->c_str());
+	break;
+      }
+    }
+    if (image.isNull())
+      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(stroke.strokeVerticesSize() != originalSize)
+      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..ecb76c4a015
--- /dev/null
+++ b/source/blender/freestyle/intern/stroke/Canvas.cpp
@@ -0,0 +1,427 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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 <qimage.h>
+#include <QString>
+#include "../image/Image.h"
+#include "../image/GaussianFilter.h"
+#include "../image/ImagePyramid.h"
+#include "../view_map/SteerableViewMap.h"
+#include "StyleModule.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;
+  }
+  QImage * qimg;
+  QImage newMap(filePath.c_str()); 
+  if(newMap.isNull()){
+    cout << "Could not load image file " << filePath << endl;
+    return;
+  }
+  qimg = &newMap;
+  
+  //resize
+  QImage scaledImg;
+  if((newMap.width()!=width()) || (newMap.height()!=height())){
+	  scaledImg = newMap.scaled(width(), height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+    qimg = &scaledImg;
+  }
+
+  // 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;
+  //  }
+
+  unsigned x,y;
+  int w = qimg->width();
+  int h = qimg->height();
+  GrayImage tmp(w,h);
+  for(y=0; y<h;++y){
+    for(x=0;x<w;++x){
+      float c = qGray(qimg->pixel(x,y));// /255.f;
+      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);
+  QString base(iMapName);
+  for(unsigned i=0; i<pyramid->getNumberOfLevels(); ++i){
+    // save each image:
+    //    w = pyramid.width(i);
+    //    h = pyramid.height(i);
+	  QImage qtmp(ow, oh, QImage::Format_RGB32);
+    //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);
+        qtmp.setPixel(x,y,qRgb(c,c,c));
+      }
+    }
+    qtmp.save(base+QString::number(i)+".bmp", "BMP");
+  }
+  //  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..cae50162933
--- /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..206b6eb7364
--- /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){
+    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..400f27e5d5a
--- /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..c3be65ffc89
--- /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..121dee3ba26
--- /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;
+  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;
+  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;
+  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;
+  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;
+  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;  
+
+  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..2542bdba147
--- /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..d6ff4d255c4
--- /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 <= _Vertices.size())
+    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..a5cf51f8224
--- /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..b89b77a85a7
--- /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..055e1fb1be4
--- /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;
+    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*iStrokeVertices.size())
+    cerr << "Warning: problem with stripe size\n";
+
+  cleanUpSingularities (iStrokeVertices);
+}	
+
+// CLEAN UP
+/////////////////////////
+
+void
+Strip::cleanUpSingularities (const vector<StrokeVertex*>& iStrokeVertices)
+{
+  int k;
+  unsigned 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, *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 (int 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)
+{
+  unsigned int sizeStrip = _vertices.size()+8; //for the transition between the tip and the body
+  vector<StrokeVertex*>::const_iterator v ,vend;
+  StrokeVertex *sv;
+
+  v=iStrokeVertices.begin();
+  vend=iStrokeVertices.end();
+  float l=(*v)->strokeLength()/_averageThickness;
+  int tiles=int(l);
+  float fact=(float(tiles)+0.5)/l;
+  float uTip2=float(tiles)+0.25;
+  float u=0; 
+  float uPrev;
+  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)
+{
+  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..129769e5489
--- /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..6d0f5aa847c
--- /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..767d82d3d98
--- /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..36bd39b2b15
--- /dev/null
+++ b/source/blender/freestyle/intern/swig/ModuleWrapper.cpp
@@ -0,0 +1,111845 @@
+/* ----------------------------------------------------------------------------
+ * 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_type swig_types[230]
+#define SWIGTYPE_p_int swig_types[231]
+#define SWIGTYPE_p_ltstr swig_types[232]
+#define SWIGTYPE_p_mapsMap swig_types[233]
+#define SWIGTYPE_p_occluder_container__const_iterator swig_types[234]
+#define SWIGTYPE_p_p_PyObject swig_types[235]
+#define SWIGTYPE_p_point_iterator swig_types[236]
+#define SWIGTYPE_p_point_type swig_types[237]
+#define SWIGTYPE_p_reference swig_types[238]
+#define SWIGTYPE_p_setTVecMat__Vec3Tdouble_t_t swig_types[239]
+#define SWIGTYPE_p_size_type swig_types[240]
+#define SWIGTYPE_p_std__invalid_argument swig_types[241]
+#define SWIGTYPE_p_std__pairTViewEdge_p_bool_t swig_types[242]
+#define SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t swig_types[243]
+#define SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type swig_types[244]
+#define SWIGTYPE_p_std__vectorTMaterial_std__allocatorTMaterial_t_t swig_types[245]
+#define SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t swig_types[246]
+#define SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type swig_types[247]
+#define SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t swig_types[248]
+#define SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type swig_types[249]
+#define SWIGTYPE_p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t swig_types[250]
+#define SWIGTYPE_p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t swig_types[251]
+#define SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t swig_types[252]
+#define SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type swig_types[253]
+#define SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t swig_types[254]
+#define SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type swig_types[255]
+#define SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t swig_types[256]
+#define SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type swig_types[257]
+#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t swig_types[258]
+#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type swig_types[259]
+#define SWIGTYPE_p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t swig_types[260]
+#define SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t swig_types[261]
+#define SWIGTYPE_p_svertices_container swig_types[262]
+#define SWIGTYPE_p_swig__PySwigIterator swig_types[263]
+#define SWIGTYPE_p_unsigned_int swig_types[264]
+#define SWIGTYPE_p_unsigned_short swig_types[265]
+#define SWIGTYPE_p_value_type swig_types[266]
+#define SWIGTYPE_p_vertex_container swig_types[267]
+#define SWIGTYPE_p_vertex_iterator swig_types[268]
+#define SWIGTYPE_p_vertex_type swig_types[269]
+#define SWIGTYPE_p_viewedge_container swig_types[270]
+#define SWIGTYPE_p_viewedges_container swig_types[271]
+#define SWIGTYPE_p_viewshapes_container swig_types[272]
+#define SWIGTYPE_p_viewvertices_container swig_types[273]
+#define SWIGTYPE_p_void swig_types[274]
+#define SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type swig_types[275]
+#define SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type swig_types[276]
+#define SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type swig_types[277]
+#define SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type swig_types[278]
+#define SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type swig_types[279]
+#define SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type swig_types[280]
+static swig_type_info *swig_types[282];
+static swig_module_info swig_module = {swig_types, 281, 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_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 *_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 *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_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 *_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 *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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "SVertex *""'"); 
+  }
+  arg1 = reinterpret_cast< SVertex * >(argp1);
+  {
+    try {
+      result = (SVertex *)(arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "FEdge *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdge * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "FEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "FEdgeSharp *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSharp * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "FEdgeSmooth *""'"); 
+  }
+  arg1 = reinterpret_cast< FEdgeSmooth * >(argp1);
+  {
+    try {
+      result = (FEdge *)(arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "SShape *""'"); 
+  }
+  arg1 = reinterpret_cast< SShape * >(argp1);
+  {
+    try {
+      result = (SShape *)(arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "ViewShape *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewShape * >(argp1);
+  {
+    try {
+      result = (ViewShape *)(arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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_dupplicate(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_dupplicate",&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_dupplicate" "', argument " "1"" of type '" "ViewEdgeInternal::SVertexIterator *""'"); 
+  }
+  arg1 = reinterpret_cast< ViewEdgeInternal::SVertexIterator * >(argp1);
+  {
+    try {
+      result = (SVertex *)(*arg1)->dupplicate();
+    }
+    //    catch (Swig::DirectorTypeMismatch&) {
+    //      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 *)"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 *)"delete_Interface0D", _wrap_delete_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 *)"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 *)"delete_Interface1D", _wrap_delete_Interface1D, 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_dupplicate", _wrap_SVertex_dupplicate, 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_dupplicate", _wrap_FEdge_dupplicate, 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_dupplicate", _wrap_FEdgeSVertexIterator_dupplicate, 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_dupplicate", _wrap_FEdgeSharp_dupplicate, 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_dupplicate", _wrap_FEdgeSmooth_dupplicate, 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_dupplicate", _wrap_SShape_dupplicate, 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_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_dupplicate", _wrap_ViewShape_dupplicate, 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_dupplicate", _wrap_ViewEdgeSVertexIterator_dupplicate, 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_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__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_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__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_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__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_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__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..ce603b17238
--- /dev/null
+++ b/source/blender/freestyle/intern/system/Interpreter.h
@@ -0,0 +1,56 @@
+//
+//  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 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..59332229ae2
--- /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 (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..f9a573ffb86
--- /dev/null
+++ b/source/blender/freestyle/intern/system/PythonInterpreter.h
@@ -0,0 +1,111 @@
+//
+//  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"
+
+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();
+    string cmd("execfile(\"" + filename + "\")");
+    char* c_cmd = strdup(cmd.c_str());
+    int err = PyRun_SimpleString(c_cmd);
+    free(c_cmd);
+    return err;
+  }
+
+  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;
+    PyRun_SimpleString("import sys");
+    vector<string> pathnames;
+    StringUtils::getPathName(_path, "", pathnames);
+    string cmd;
+    char* c_cmd;
+    for (vector<string>::const_iterator it = pathnames.begin();
+	 it != pathnames.end();
+	 ++it) {
+      cmd = "sys.path.append(\"" + *it + "\")";
+      c_cmd = strdup(cmd.c_str());
+      PyRun_SimpleString(c_cmd);
+      free(c_cmd);
+    }
+    //    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..2af76feeb37
--- /dev/null
+++ b/source/blender/freestyle/intern/system/StringUtils.cpp
@@ -0,0 +1,46 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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 <qfileinfo.h>
+#include "FreestyleConfig.h"
+#include "StringUtils.h"
+
+namespace StringUtils {
+
+  void getPathName(const string& path, const string& base, vector<string>& pathnames) {
+    string dir;
+    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);
+      QFileInfo fi(dir.c_str());
+      string res = (const char*)fi.absoluteFilePath().toAscii();
+      if (!base.empty())
+	res += Config::DIR_SEP + base;
+      pathnames.push_back(res);
+    }
+  }
+
+} // 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..44adfc2b044
--- /dev/null
+++ b/source/blender/freestyle/intern/system/StringUtils.h
@@ -0,0 +1,51 @@
+//
+//  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 "FreestyleConfig.h"
+
+using namespace std;
+
+namespace StringUtils {
+
+  LIB_SYSTEM_EXPORT 
+  void getPathName(const string& path, const string& base, vector<string>& pathnames);
+
+  // 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..628b3ad77aa
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp
@@ -0,0 +1,677 @@
+
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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
+
+  real K1, K2, 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..38d0f34e21f
--- /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
+  //tmp 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..eec39d2f7bc
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Interface0D.h
@@ -0,0 +1,351 @@
+//
+//  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:
+
+  /*! 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..812187e5ec1
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Interface1D.h
@@ -0,0 +1,202 @@
+//
+//  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;}
+
+  /*! 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() = 0;
+  /*! Returns an iterator over the Interface1D vertices,
+   *  pointing after the last vertex.
+   */
+  virtual Interface0DIterator verticesEnd() = 0;
+  /*! 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) = 0;
+  /*! 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) = 0;
+
+  // 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..e88bf23b210
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/Silhouette.h
@@ -0,0 +1,1417 @@
+//
+//  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 * dupplicate() {
+    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;
+    _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* dupplicate()
+  {
+    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* dupplicate(){
+    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* dupplicate(){
+    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)->dupplicate();
+        _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 * dupplicate()
+  {
+    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)
+    {
+      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..19b8a632ffe
--- /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..159dda1afc0
--- /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..b2604606aa7
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/SteerableViewMap.cpp
@@ -0,0 +1,243 @@
+//
+//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+//   with this source distribution. 
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public 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;
+
+#include <qstring.h>
+#include <qimage.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);
+  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);
+    QString base("SteerableViewMap");
+    for(unsigned j=0; j<_imagesPyramids[i]->getNumberOfLevels(); ++j){
+      float coeff = 1;//1/255.f; //100*255;//*pow(2,j);
+	  QImage qtmp(ow, oh, QImage::Format_RGB32);
+      for(unsigned y=0;y<oh;++y){
+        for(unsigned x=0;x<ow;++x){
+          int c = (int)(coeff*_imagesPyramids[i]->pixel(x,y,j));
+          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");
+    }
+    //    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..20b3aeb144d
--- /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;
+  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;
+  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..9e2837b49a7
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h
@@ -0,0 +1,214 @@
+//
+//  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>
+
+# 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);
+
+  //tmp 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..9a2d262b703
--- /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..bdbb140e130
--- /dev/null
+++ b/source/blender/freestyle/intern/view_map/ViewMap.h
@@ -0,0 +1,1487 @@
+//
+//  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 * dupplicate() = 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 * dupplicate()
+  {
+    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 * dupplicate()
+  {
+    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 * dupplicate()
+  {
+    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();
+    // dupplicate vertices
+    for(vv=vvertices.begin(), vvend=vvertices.end();
+    vv!=vvend;
+    vv++)
+    {
+      ViewVertex * newVertex = (*vv)->dupplicate();
+      AddVertex(newVertex);
+    }
+
+    vector<ViewEdge*>& vvedges = iBrother.edges();
+    // dupplicate edges
+    for(ve=vvedges.begin(), veend=vvedges.end();
+    ve!=veend;
+    ve++)
+    {
+      ViewEdge * newEdge = (*ve)->dupplicate();
+      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 * dupplicate()
+  {
+    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..32f5283a63c
--- /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..ec52d4fdd7e
--- /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..d68164973a1
--- /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;
+
+    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..fc1ec8e373e
--- /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..79b3a8dae26
--- /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::dupplicate()
+{
+  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::dupplicate()
+{
+  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->dupplicate();
+  if(NULL != boedge)
+    //_pbOEdge = new WOEdge(*boedge);
+    _pbOEdge = boedge->dupplicate();
+  
+  _nOEdges = iBrother.GetNumberOfOEdges();
+  _Id = iBrother.GetId();
+  iBrother.userdata = new edgedata;
+  ((edgedata*)(iBrother.userdata))->_copy = this;
+}
+
+WEdge * WEdge::dupplicate()
+{
+  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::dupplicate()
+{
+  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::dupplicate()
+{
+  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)->dupplicate();
+
+    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)->dupplicate();
+    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)->dupplicate();
+    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..2369caf4566
--- /dev/null
+++ b/source/blender/freestyle/intern/winged_edge/WEdge.h
@@ -0,0 +1,952 @@
+//
+//  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 * dupplicate(); 
+  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
+
+  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
+
+  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;
+  }
+
+  /*! copy constructor */
+  WOEdge(WOEdge& iBrother);
+  virtual WOEdge * dupplicate();
+
+  /*! 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 * dupplicate();
+
+  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 * dupplicate();
+  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 * dupplicate();
+  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..cf3734b488e
--- /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 "WSEdge.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..976fdca8e46
--- /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 "Grid.h" 
+# include "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..115a4f61789
--- /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..beacb1a9ca9
--- /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 * dupplicate()
+  {
+    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 * dupplicate()
+  {
+    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;
+
+  //tmp 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 * dupplicate()
+  {
+    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 * dupplicate()
+  {
+    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..534c6e323a9
--- /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..98e7c269248
--- /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();
+  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)
+}