diff options
Diffstat (limited to 'source/blender/freestyle/intern/swig')
| -rwxr-xr-x | source/blender/freestyle/intern/swig/Freestyle.i | 283 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/FreestyleWrapper.vc7.vcproj | 217 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/FreestyleWrapper.vc8.vcproj | 283 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/Makefile | 90 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/Makefile.cygwin | 92 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/Makefile.linux | 91 | ||||
| -rw-r--r-- | source/blender/freestyle/intern/swig/Makefile.mac | 91 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/Makefile.noswig | 64 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/ModuleWrapper.cpp | 111845 | ||||
| -rwxr-xr-x | source/blender/freestyle/intern/swig/ModuleWrapper.h | 1045 |
10 files changed, 114101 insertions, 0 deletions
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"$(SWIG_INC)\python" -I"$(SWIG_INC)" -o ModuleWrapper.cpp "$(InputPath)" +" + 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"$(SWIG_INC)\python" -I"$(SWIG_INC)" -o ModuleWrapper.cpp "$(InputPath)" +" + 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\
copy ..\..\build\win32\release\python\_Freestyle.dll ..\..\build\win32\release\python\_Freestyle.pyd
" + /> + </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\
copy ..\..\build\win32\debug\python\_Freestyle.dll ..\..\build\win32\debug\python\_Freestyle.pyd
" + /> + </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:
echo PYTHON_INCLUDE: %PYTHON_INCLUDE%
echo PYTHON_LIB: %PYTHON_LIB%
echo on
swig -c++ -python -I"$(SWIG_INC)\python" -I"$(SWIG_INC)" -o ModuleWrapper.cpp "$(InputPath)"
" + 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"$(SWIG_INC)\python" -I"$(SWIG_INC)" -o ModuleWrapper.cpp "$(InputPath)"
" + 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 |