void register_Vec2d_class(){
{ //::osg::Vec2d
typedef bp::class_< osg::Vec2d > Vec2d_exposer_t;
Vec2d_exposer_t Vec2d_exposer = Vec2d_exposer_t( "Vec2d", "\n General purpose double pair, uses include representation of\n texture coordinates.\n No support yet added for double * Vec2d - is it necessary?\n Need to define a non-member non-friend operator* etc.\n BTW: Vec2d * double is okay\n", bp::init< >("\n Constructor that sets all components of the vector to zero\n") );
bp::scope Vec2d_scope( Vec2d_exposer );
bp::scope().attr("num_components") = (int)osg::Vec2d::num_components;
Vec2d_exposer.def( bp::init< double, double >(( bp::arg("x"), bp::arg("y") )) );
Vec2d_exposer.def( bp::init< osg::Vec2f const & >(( bp::arg("vec") )) );
bp::implicitly_convertible< osg::Vec2f const &, osg::Vec2d >();
{ //::osg::Vec2d::isNaN
typedef bool ( ::osg::Vec2d::*isNaN_function_type )( ) const;
Vec2d_exposer.def(
"isNaN"
, isNaN_function_type( &::osg::Vec2d::isNaN )
, "\n Returns true if at least one component has value NaN.\n" );
}
{ //::osg::Vec2d::length
typedef double ( ::osg::Vec2d::*length_function_type )( ) const;
Vec2d_exposer.def(
"length"
, length_function_type( &::osg::Vec2d::length )
, "\n Length of the vector = sqrt( vec . vec )\n" );
}
{ //::osg::Vec2d::length2
typedef double ( ::osg::Vec2d::*length2_function_type )( ) const;
Vec2d_exposer.def(
"length2"
, length2_function_type( &::osg::Vec2d::length2 )
, "\n Length squared of the vector = vec . vec\n" );
}
{ //::osg::Vec2d::normalize
typedef double ( ::osg::Vec2d::*normalize_function_type )( ) ;
Vec2d_exposer.def(
"normalize"
, normalize_function_type( &::osg::Vec2d::normalize )
, "\n Normalize the vector so that it has length unity.\n Returns the previous length of the vector.\n" );
}
Vec2d_exposer.def( "as__scope_osg_scope_Vec2f", &osg::Vec2d::operator ::osg::Vec2f );
Vec2d_exposer.def( bp::self != bp::self );
Vec2d_exposer.def( bp::self * bp::self );
Vec2d_exposer.def( bp::self * bp::other< double >() );
Vec2d_exposer.def( bp::self *= bp::other< double >() );
Vec2d_exposer.def( bp::self + bp::self );
Vec2d_exposer.def( bp::self += bp::self );
Vec2d_exposer.def( bp::self - bp::self );
Vec2d_exposer.def( -bp::self );
Vec2d_exposer.def( bp::self -= bp::self );
Vec2d_exposer.def( bp::self / bp::other< double >() );
Vec2d_exposer.def( bp::self /= bp::other< double >() );
Vec2d_exposer.def( bp::self < bp::self );
Vec2d_exposer.def( bp::self == bp::self );
{ //::osg::Vec2d::operator[]
typedef double & ( ::osg::Vec2d::*__getitem___function_type )( int ) ;
Vec2d_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Vec2d::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Vec2d::operator[]
typedef double ( ::osg::Vec2d::*__getitem___function_type )( int ) const;
Vec2d_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Vec2d::operator[] )
, ( bp::arg("i") ) );
}
{ //::osg::Vec2d::set
typedef void ( ::osg::Vec2d::*set_function_type )( double,double ) ;
Vec2d_exposer.def(
"set"
, set_function_type( &::osg::Vec2d::set )
, ( bp::arg("x"), bp::arg("y") ) );
}
{ //::osg::Vec2d::valid
typedef bool ( ::osg::Vec2d::*valid_function_type )( ) const;
Vec2d_exposer.def(
"valid"
, valid_function_type( &::osg::Vec2d::valid )
, "\n Returns true if all components have values that are not NaN.\n" );
}
{ //property "x"[fget=::osg::Vec2d::x]
typedef double & ( ::osg::Vec2d::*fget )( ) ;
Vec2d_exposer.add_property(
"x"
, bp::make_function(
fget( &::osg::Vec2d::x )
, bp::return_value_policy< bp::copy_non_const_reference >() ) );
}
{ //property "x"[fget=::osg::Vec2d::x]
typedef double ( ::osg::Vec2d::*fget )( ) const;
Vec2d_exposer.add_property(
"x"
, fget( &::osg::Vec2d::x ) );
}
{ //property "y"[fget=::osg::Vec2d::y]
typedef double & ( ::osg::Vec2d::*fget )( ) ;
Vec2d_exposer.add_property(
"y"
, bp::make_function(
fget( &::osg::Vec2d::y )
, bp::return_value_policy< bp::copy_non_const_reference >() ) );
}
{ //property "y"[fget=::osg::Vec2d::y]
typedef double ( ::osg::Vec2d::*fget )( ) const;
Vec2d_exposer.add_property(
"y"
, fget( &::osg::Vec2d::y ) );
}
Vec2d_exposer.def( bp::self_ns::str( bp::self ) );
Vec2d_exposer.def( bp::self_ns::str(bp::self) );
Vec2d_exposer.def(bp::indexing::container_suite<
osg::Vec2d,
bp::indexing::all_methods,
OsgVec_algorithms<osg::Vec2d, osg::Vec2d::value_type, osg::Vec2d::num_components> >());
}
}
void register_Vec3f_class(){
{ //::osg::Vec3f
typedef bp::class_< osg::Vec3f > Vec3f_exposer_t;
Vec3f_exposer_t Vec3f_exposer = Vec3f_exposer_t( "Vec3f", "\n General purpose float triple for use as vertices, vectors and normals.\n Provides general math operations from addition through to cross products.\n No support yet added for float * Vec3f - is it necessary?\n Need to define a non-member non-friend operator* etc.\n Vec3f * float is okay\n", bp::init< >("\n Constructor that sets all components of the vector to zero\n") );
bp::scope Vec3f_scope( Vec3f_exposer );
bp::scope().attr("num_components") = (int)osg::Vec3f::num_components;
Vec3f_exposer.def( bp::init< float, float, float >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) );
Vec3f_exposer.def( bp::init< osg::Vec2f const &, float >(( bp::arg("v2"), bp::arg("zz") )) );
{ //::osg::Vec3f::isNaN
typedef bool ( ::osg::Vec3f::*isNaN_function_type)( ) const;
Vec3f_exposer.def(
"isNaN"
, isNaN_function_type( &::osg::Vec3f::isNaN )
, "\n Returns true if at least one component has value NaN.\n" );
}
{ //::osg::Vec3f::length
typedef float ( ::osg::Vec3f::*length_function_type)( ) const;
Vec3f_exposer.def(
"length"
, length_function_type( &::osg::Vec3f::length )
, "\n Length of the vector = sqrt( vec . vec )\n" );
}
{ //::osg::Vec3f::length2
typedef float ( ::osg::Vec3f::*length2_function_type)( ) const;
Vec3f_exposer.def(
"length2"
, length2_function_type( &::osg::Vec3f::length2 )
, "\n Length squared of the vector = vec . vec\n" );
}
{ //::osg::Vec3f::normalize
typedef float ( ::osg::Vec3f::*normalize_function_type)( ) ;
Vec3f_exposer.def(
"normalize"
, normalize_function_type( &::osg::Vec3f::normalize )
, "\n Normalize the vector so that it has length unity.\n Returns the previous length of the vector.\n" );
}
Vec3f_exposer.def( bp::self != bp::self );
Vec3f_exposer.def( bp::self * bp::self );
Vec3f_exposer.def( bp::self * bp::other< float >() );
Vec3f_exposer.def( bp::self *= bp::other< float >() );
Vec3f_exposer.def( bp::self + bp::self );
Vec3f_exposer.def( bp::self += bp::self );
Vec3f_exposer.def( bp::self - bp::self );
Vec3f_exposer.def( -bp::self );
Vec3f_exposer.def( bp::self -= bp::self );
Vec3f_exposer.def( bp::self / bp::other< float >() );
Vec3f_exposer.def( bp::self /= bp::other< float >() );
Vec3f_exposer.def( bp::self < bp::self );
Vec3f_exposer.def( bp::self == bp::self );
{ //::osg::Vec3f::operator[]
typedef float & ( ::osg::Vec3f::*__getitem___function_type)( int ) ;
Vec3f_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Vec3f::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Vec3f::operator[]
typedef float ( ::osg::Vec3f::*__getitem___function_type)( int ) const;
Vec3f_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Vec3f::operator[] )
, ( bp::arg("i") ) );
}
Vec3f_exposer.def( bp::self ^ bp::self );
{ //::osg::Vec3f::set
typedef void ( ::osg::Vec3f::*set_function_type)( float,float,float ) ;
Vec3f_exposer.def(
"set"
, set_function_type( &::osg::Vec3f::set )
, ( bp::arg("x"), bp::arg("y"), bp::arg("z") ) );
}
{ //::osg::Vec3f::set
typedef void ( ::osg::Vec3f::*set_function_type)( ::osg::Vec3f const & ) ;
Vec3f_exposer.def(
"set"
, set_function_type( &::osg::Vec3f::set )
, ( bp::arg("rhs") ) );
}
{ //::osg::Vec3f::valid
typedef bool ( ::osg::Vec3f::*valid_function_type)( ) const;
Vec3f_exposer.def(
"valid"
, valid_function_type( &::osg::Vec3f::valid )
, "\n Returns true if all components have values that are not NaN.\n" );
}
{ //property "x"[fget=::osg::Vec3f::x]
typedef float & ( ::osg::Vec3f::*fget)( ) ;
Vec3f_exposer.add_property(
"x"
, bp::make_function(
fget( &::osg::Vec3f::x )
, bp::return_value_policy< bp::copy_non_const_reference >() ) );
}
{ //property "x"[fget=::osg::Vec3f::x]
typedef float ( ::osg::Vec3f::*fget)( ) const;
Vec3f_exposer.add_property(
"x"
, fget( &::osg::Vec3f::x ) );
}
{ //property "y"[fget=::osg::Vec3f::y]
typedef float & ( ::osg::Vec3f::*fget)( ) ;
Vec3f_exposer.add_property(
"y"
, bp::make_function(
fget( &::osg::Vec3f::y )
, bp::return_value_policy< bp::copy_non_const_reference >() ) );
}
{ //property "y"[fget=::osg::Vec3f::y]
typedef float ( ::osg::Vec3f::*fget)( ) const;
Vec3f_exposer.add_property(
"y"
, fget( &::osg::Vec3f::y ) );
}
{ //property "z"[fget=::osg::Vec3f::z]
typedef float & ( ::osg::Vec3f::*fget)( ) ;
Vec3f_exposer.add_property(
"z"
, bp::make_function(
fget( &::osg::Vec3f::z )
, bp::return_value_policy< bp::copy_non_const_reference >() ) );
}
{ //property "z"[fget=::osg::Vec3f::z]
typedef float ( ::osg::Vec3f::*fget)( ) const;
Vec3f_exposer.add_property(
"z"
, fget( &::osg::Vec3f::z ) );
}
Vec3f_exposer.def( bp::self * bp::other< osg::Matrixf >() );
Vec3f_exposer.def( bp::self * bp::other< osg::Matrixd >() );
Vec3f_exposer.def( bp::self * bp::other< osg::Vec4d >() );
Vec3f_exposer.def( bp::self * bp::other< osg::Vec4f >() );
Vec3f_exposer.def( bp::self_ns::str( bp::self ) );
Vec3f_exposer.def( bp::self_ns::str(bp::self) );
Vec3f_exposer.def(bp::indexing::container_suite<
osg::Vec3f,
bp::indexing::all_methods,
OsgVec_algorithms<osg::Vec3f, osg::Vec3f::value_type, osg::Vec3f::num_components> >());
}
}
void register_ArgumentParser_class(){
{ //::osg::ArgumentParser
typedef bp::class_< osg::ArgumentParser > ArgumentParser_exposer_t;
ArgumentParser_exposer_t ArgumentParser_exposer = ArgumentParser_exposer_t( "ArgumentParser", bp::no_init );
bp::scope ArgumentParser_scope( ArgumentParser_exposer );
bp::enum_< osg::ArgumentParser::ErrorSeverity>("ErrorSeverity")
.value("BENIGN", osg::ArgumentParser::BENIGN)
.value("CRITICAL", osg::ArgumentParser::CRITICAL)
.export_values()
;
{ //::osg::ArgumentParser::Parameter
typedef bp::class_< osg::ArgumentParser::Parameter > Parameter_exposer_t;
Parameter_exposer_t Parameter_exposer = Parameter_exposer_t( "Parameter", bp::init< bool & >(( bp::arg("value") )) );
bp::scope Parameter_scope( Parameter_exposer );
bp::enum_< osg::ArgumentParser::Parameter::ParameterType>("ParameterType")
.value("BOOL_PARAMETER", osg::ArgumentParser::Parameter::BOOL_PARAMETER)
.value("FLOAT_PARAMETER", osg::ArgumentParser::Parameter::FLOAT_PARAMETER)
.value("DOUBLE_PARAMETER", osg::ArgumentParser::Parameter::DOUBLE_PARAMETER)
.value("INT_PARAMETER", osg::ArgumentParser::Parameter::INT_PARAMETER)
.value("UNSIGNED_INT_PARAMETER", osg::ArgumentParser::Parameter::UNSIGNED_INT_PARAMETER)
.value("STRING_PARAMETER", osg::ArgumentParser::Parameter::STRING_PARAMETER)
.export_values()
;
bp::implicitly_convertible< bool &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< float & >(( bp::arg("value") )) );
bp::implicitly_convertible< float &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< double & >(( bp::arg("value") )) );
bp::implicitly_convertible< double &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< int & >(( bp::arg("value") )) );
bp::implicitly_convertible< int &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< unsigned int & >(( bp::arg("value") )) );
bp::implicitly_convertible< unsigned int &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< std::string & >(( bp::arg("value") )) );
bp::implicitly_convertible< std::string &, osg::ArgumentParser::Parameter >();
Parameter_exposer.def( bp::init< osg::ArgumentParser::Parameter const & >(( bp::arg("param") )) );
{ //::osg::ArgumentParser::Parameter::assign
typedef bool ( ::osg::ArgumentParser::Parameter::*assign_function_type)( char const * ) ;
Parameter_exposer.def(
"assign"
, assign_function_type( &::osg::ArgumentParser::Parameter::assign )
, ( bp::arg("str") ) );
}
{ //::osg::ArgumentParser::Parameter::operator=
typedef ::osg::ArgumentParser::Parameter & ( ::osg::ArgumentParser::Parameter::*assign_function_type)( ::osg::ArgumentParser::Parameter const & ) ;
Parameter_exposer.def(
"assign"
, assign_function_type( &::osg::ArgumentParser::Parameter::operator= )
, ( bp::arg("param") )
, bp::return_self< >() );
}
{ //::osg::ArgumentParser::Parameter::valid
typedef bool ( ::osg::ArgumentParser::Parameter::*valid_function_type)( char const * ) const;
Parameter_exposer.def(
"valid"
, valid_function_type( &::osg::ArgumentParser::Parameter::valid )
, ( bp::arg("str") ) );
}
}
ArgumentParser_exposer.def( bp::init< int *, char * * >(( bp::arg("argc"), bp::arg("argv") )) );
{ //::osg::ArgumentParser::argc
typedef int & ( ::osg::ArgumentParser::*argc_function_type)( ) ;
ArgumentParser_exposer.def(
"argc"
, argc_function_type( &::osg::ArgumentParser::argc )
, bp::return_value_policy< bp::copy_non_const_reference >()
, "\n Return the argument count.\n" );
}
{ //::osg::ArgumentParser::containsOptions
typedef bool ( ::osg::ArgumentParser::*containsOptions_function_type)( ) const;
ArgumentParser_exposer.def(
"containsOptions"
, containsOptions_function_type( &::osg::ArgumentParser::containsOptions ) );
}
{ //::osg::ArgumentParser::errors
typedef bool ( ::osg::ArgumentParser::*errors_function_type)( ::osg::ArgumentParser::ErrorSeverity ) const;
ArgumentParser_exposer.def(
"errors"
, errors_function_type( &::osg::ArgumentParser::errors )
, ( bp::arg("severity")=::osg::ArgumentParser::BENIGN )
, "\n Return the error flag, true if an error has occurred when reading arguments.\n" );
}
{ //::osg::ArgumentParser::find
typedef int ( ::osg::ArgumentParser::*find_function_type)( ::std::string const & ) const;
ArgumentParser_exposer.def(
"find"
, find_function_type( &::osg::ArgumentParser::find )
, ( bp::arg("str") )
, "\n Return the position of an occurrence of a string in the argument list.\n Return -1 if no string is found.\n" );
}
{ //::osg::ArgumentParser::getApplicationName
typedef ::std::string ( ::osg::ArgumentParser::*getApplicationName_function_type)( ) const;
ArgumentParser_exposer.def(
"getApplicationName"
, getApplicationName_function_type( &::osg::ArgumentParser::getApplicationName )
, "\n Return the application name, as specified by argv[0]\n" );
}
{ //::osg::ArgumentParser::getApplicationUsage
typedef ::osg::ApplicationUsage * ( ::osg::ArgumentParser::*getApplicationUsage_function_type)( ) ;
ArgumentParser_exposer.def(
"getApplicationUsage"
, getApplicationUsage_function_type( &::osg::ArgumentParser::getApplicationUsage )
, bp::return_internal_reference< >() );
}
{ //::osg::ArgumentParser::getApplicationUsage
typedef ::osg::ApplicationUsage const * ( ::osg::ArgumentParser::*getApplicationUsage_function_type)( ) const;
ArgumentParser_exposer.def(
"getApplicationUsage"
, getApplicationUsage_function_type( &::osg::ArgumentParser::getApplicationUsage )
, bp::return_internal_reference< >() );
}
{ //::osg::ArgumentParser::getErrorMessageMap
typedef ::std::map< std::string, osg::ArgumentParser::ErrorSeverity > & ( ::osg::ArgumentParser::*getErrorMessageMap_function_type)( ) ;
ArgumentParser_exposer.def(
"getErrorMessageMap"
, getErrorMessageMap_function_type( &::osg::ArgumentParser::getErrorMessageMap )
, bp::return_internal_reference< >()
, "\n Return the error message, if any has occurred.\n" );
}
{ //::osg::ArgumentParser::getErrorMessageMap
typedef ::std::map< std::string, osg::ArgumentParser::ErrorSeverity > const & ( ::osg::ArgumentParser::*getErrorMessageMap_function_type)( ) const;
ArgumentParser_exposer.def(
"getErrorMessageMap"
, getErrorMessageMap_function_type( &::osg::ArgumentParser::getErrorMessageMap )
, bp::return_internal_reference< >()
, "\n Return the error message, if any has occurred.\n" );
}
{ //::osg::ArgumentParser::isBool
typedef bool ( *isBool_function_type )( char const * );
ArgumentParser_exposer.def(
"isBool"
, isBool_function_type( &::osg::ArgumentParser::isBool )
, ( bp::arg("str") )
, "\n Return true if specified parameter is a bool.\n" );
}
{ //::osg::ArgumentParser::isNumber
typedef bool ( *isNumber_function_type )( char const * );
ArgumentParser_exposer.def(
"isNumber"
, isNumber_function_type( &::osg::ArgumentParser::isNumber )
, ( bp::arg("str") )
, "\n Return true if specified parameter is a number.\n" );
}
{ //::osg::ArgumentParser::isNumber
typedef bool ( ::osg::ArgumentParser::*isNumber_function_type)( int ) const;
ArgumentParser_exposer.def(
"isNumber"
, isNumber_function_type( &::osg::ArgumentParser::isNumber )
, ( bp::arg("pos") )
, "\n Return true if the specified parameter is a number.\n" );
}
{ //::osg::ArgumentParser::isOption
typedef bool ( *isOptionStr_function_type )( char const * );
ArgumentParser_exposer.def(
"isOptionStr"
, isOptionStr_function_type( &::osg::ArgumentParser::isOption )
, ( bp::arg("str") )
, "\n Return true if the specified string is an option in the form\n -option or --option.\n" );
}
{ //::osg::ArgumentParser::isOption
typedef bool ( ::osg::ArgumentParser::*isOption_function_type)( int ) const;
ArgumentParser_exposer.def(
"isOption"
, isOption_function_type( &::osg::ArgumentParser::isOption )
, ( bp::arg("pos") )
, "\n Return true if the specified parameter is an option in the form of\n -option or --option.\n" );
}
{ //::osg::ArgumentParser::isString
typedef bool ( *isString_function_type )( char const * );
ArgumentParser_exposer.def(
"isString"
, isString_function_type( &::osg::ArgumentParser::isString )
, ( bp::arg("str") )
, "\n Return true if string is non-NULL and not an option in the form\n -option or --option.\n" );
}
{ //::osg::ArgumentParser::isString
typedef bool ( ::osg::ArgumentParser::*isString_function_type)( int ) const;
ArgumentParser_exposer.def(
"isString"
, isString_function_type( &::osg::ArgumentParser::isString )
, ( bp::arg("pos") )
, "\n Return true if the specified parameter is a string not in\n the form of an option.\n" );
}
{ //::osg::ArgumentParser::match
typedef bool ( ::osg::ArgumentParser::*match_function_type)( int,::std::string const & ) const;
ArgumentParser_exposer.def(
"match"
, match_function_type( &::osg::ArgumentParser::match )
, ( bp::arg("pos"), bp::arg("str") )
, "\n Return true if the specified argument matches the given string.\n" );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const & ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str") )
, "\n Search for an occurrence of a string in the argument list. If found,\n remove that occurrence and return true. Otherwise, return false.\n" );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( ::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7"), bp::arg("value8") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const & ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str") )
, "\n If the argument value at the specified position matches the given string,\n and subsequent parameters are also matched, then set the parameter values,\n remove the arguments from the list, and return true. Otherwise, return false.\n" );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7") ) );
}
{ //::osg::ArgumentParser::read
typedef bool ( ::osg::ArgumentParser::*read_function_type)( int,::std::string const &,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter,::osg::ArgumentParser::Parameter ) ;
ArgumentParser_exposer.def(
"read"
, read_function_type( &::osg::ArgumentParser::read )
, ( bp::arg("pos"), bp::arg("str"), bp::arg("value1"), bp::arg("value2"), bp::arg("value3"), bp::arg("value4"), bp::arg("value5"), bp::arg("value6"), bp::arg("value7"), bp::arg("value8") ) );
}
{ //::osg::ArgumentParser::readHelpType
typedef ::osg::ApplicationUsage::Type ( ::osg::ArgumentParser::*readHelpType_function_type)( ) ;
ArgumentParser_exposer.def(
"readHelpType"
, readHelpType_function_type( &::osg::ArgumentParser::readHelpType )
, "\n This convenience method handles help requests on the command line.\n Return the type(s) of help requested. The return value of this\n function is suitable for passing into getApplicationUsage()->write().\n If ApplicationUsage::NO_HELP is returned then no help commandline option\n was found on the command line.\n" );
}
{ //::osg::ArgumentParser::remove
typedef void ( ::osg::ArgumentParser::*remove_function_type)( int,int ) ;
ArgumentParser_exposer.def(
"remove"
, remove_function_type( &::osg::ArgumentParser::remove )
, ( bp::arg("pos"), bp::arg("num")=(int)(1) )
, "\n Remove one or more arguments from the argv argument list,\n and decrement the argc respectively.\n" );
}
{ //::osg::ArgumentParser::reportError
typedef void ( ::osg::ArgumentParser::*reportError_function_type)( ::std::string const &,::osg::ArgumentParser::ErrorSeverity ) ;
ArgumentParser_exposer.def(
"reportError"
, reportError_function_type( &::osg::ArgumentParser::reportError )
, ( bp::arg("message"), bp::arg("severity")=::osg::ArgumentParser::CRITICAL )
, "\n Report an error message by adding to the ErrorMessageMap.\n" );
}
{ //::osg::ArgumentParser::reportRemainingOptionsAsUnrecognized
typedef void ( ::osg::ArgumentParser::*reportRemainingOptionsAsUnrecognized_function_type)( ::osg::ArgumentParser::ErrorSeverity ) ;
ArgumentParser_exposer.def(
"reportRemainingOptionsAsUnrecognized"
, reportRemainingOptionsAsUnrecognized_function_type( &::osg::ArgumentParser::reportRemainingOptionsAsUnrecognized )
, ( bp::arg("severity")=::osg::ArgumentParser::BENIGN )
, "\n For each remaining option, report it as unrecognized.\n" );
}
{ //::osg::ArgumentParser::setApplicationUsage
typedef void ( ::osg::ArgumentParser::*setApplicationUsage_function_type)( ::osg::ApplicationUsage * ) ;
ArgumentParser_exposer.def(
"setApplicationUsage"
, setApplicationUsage_function_type( &::osg::ArgumentParser::setApplicationUsage )
, ( bp::arg("usage") ) );
}
{ //::osg::ArgumentParser::writeErrorMessages
typedef void ( ::osg::ArgumentParser::*writeErrorMessages_function_type)( ::std::ostream &,::osg::ArgumentParser::ErrorSeverity ) ;
ArgumentParser_exposer.def(
"writeErrorMessages"
, writeErrorMessages_function_type( &::osg::ArgumentParser::writeErrorMessages )
, ( bp::arg("output"), bp::arg("sevrity")=::osg::ArgumentParser::BENIGN )
, "\n Write error messages to the given ostream, if at or above the given severity.\n" );
}
ArgumentParser_exposer.staticmethod( "isBool" );
ArgumentParser_exposer.staticmethod( "isNumber" );
ArgumentParser_exposer.staticmethod( "isOptionStr" );
ArgumentParser_exposer.staticmethod( "isString" );
ArgumentParser_exposer.def( "__init__", bp::make_constructor( &initArgumentParser ) );
ArgumentParser_exposer.def( "__init__", bp::make_constructor( &initArgumentParser2 ) );
ArgumentParser_exposer.def( "__getitem__", &getArgumentParserItem );
}
}
void register_Plane_class(){
{ //::osg::Plane
typedef bp::class_< osg::Plane > Plane_exposer_t;
Plane_exposer_t Plane_exposer = Plane_exposer_t( "Plane", "\n A plane class. It can be used to represent an infinite plane.\n\n The infinite plane is described by an implicit plane equation a*x+b*y+c*z+d = 0. Though it is not mandatory that\n a^2+b^2+c^2 = 1 is fulfilled in general some methods require it (aee osg::Plane::distance).\n", bp::init< >("\n Default constructor\n The default constructor initializes all values to zero.\n Warning: Although the method osg::Plane::valid() will return true after the default constructors call the plane\n is mathematically invalid! Default data do not describe a valid plane.\n") );
bp::scope Plane_scope( Plane_exposer );
bp::scope().attr("num_components") = (int)osg::Plane::num_components;
Plane_exposer.def( bp::init< osg::Plane const & >(( bp::arg("pl") )) );
Plane_exposer.def( bp::init< double, double, double, double >(( bp::arg("a"), bp::arg("b"), bp::arg("c"), bp::arg("d") ), "\n Constructor\n The plane is described as a*x+b*y+c*z+d = 0.\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed values are not normalized.\n") );
Plane_exposer.def( bp::init< osg::Vec4f const & >(( bp::arg("vec") ), "\n Constructor\n The plane can also be described as vec*[x,y,z,1].\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed values are not normalized.\n") );
bp::implicitly_convertible< osg::Vec4f const &, osg::Plane >();
Plane_exposer.def( bp::init< osg::Vec4d const & >(( bp::arg("vec") ), "\n Constructor\n The plane can also be described as vec*[x,y,z,1].\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed values are not normalized.\n") );
bp::implicitly_convertible< osg::Vec4d const &, osg::Plane >();
Plane_exposer.def( bp::init< osg::Vec3d const &, double >(( bp::arg("norm"), bp::arg("d") ), "\n Constructor\n This constructor initializes the internal values directly without any checking or manipulation.\n @param norm: The normal of the plane.\n @param d: The negative distance from the point of origin to the plane.\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed normal was not normalized.\n") );
Plane_exposer.def( bp::init< osg::Vec3d const &, osg::Vec3d const &, osg::Vec3d const & >(( bp::arg("v1"), bp::arg("v2"), bp::arg("v3") ), "\n Constructor\n This constructor calculates from the three points describing an infinite plane the internal values.\n @param v1: Point in the plane.\n @param v2: Point in the plane.\n @param v3: Point in the plane.\n @remark After this constructor call the planes normal is normalized in case the three points described a mathematically\n valid plane.\n @remark The normal is determined by building the cross product of (v2-v1) ^ (v3-v2).\n") );
Plane_exposer.def( bp::init< osg::Vec3d const &, osg::Vec3d const & >(( bp::arg("norm"), bp::arg("point") ), "\n Constructor\n This constructor initializes the internal values directly without any checking or manipulation.\n @param norm: The normal of the plane.\n @param point: A point of the plane.\n @remark You may call osg::Plane::MakeUnitLength afterwards if the passed normal was not normalized.\n") );
{ //::osg::Plane::asVec4
typedef ::osg::Vec4d ( ::osg::Plane::*asVec4_function_type)( ) const;
Plane_exposer.def(
"asVec4"
, asVec4_function_type( &::osg::Plane::asVec4 ) );
}
{ //::osg::Plane::calculateUpperLowerBBCorners
typedef void ( ::osg::Plane::*calculateUpperLowerBBCorners_function_type)( ) ;
Plane_exposer.def(
"calculateUpperLowerBBCorners"
, calculateUpperLowerBBCorners_function_type( &::osg::Plane::calculateUpperLowerBBCorners )
, "\n calculate the upper and lower bounding box corners to be used\n in the intersect(BoundingBox&) method for speeding calculations.\n" );
}
{ //::osg::Plane::distance
typedef float ( ::osg::Plane::*distance_function_type)( ::osg::Vec3f const & ) const;
Plane_exposer.def(
"distance"
, distance_function_type( &::osg::Plane::distance )
, ( bp::arg("v") )
, "\n Calculate the distance between a point and the plane.\n @remark This method only leads to real distance values if the planes norm is 1.\n aa osg::Plane::makeUnitLength\n" );
}
{ //::osg::Plane::distance
typedef double ( ::osg::Plane::*distance_function_type)( ::osg::Vec3d const & ) const;
Plane_exposer.def(
"distance"
, distance_function_type( &::osg::Plane::distance )
, ( bp::arg("v") )
, "\n Calculate the distance between a point and the plane.\n @remark This method only leads to real distance values if the planes norm is 1.\n aa osg::Plane::makeUnitLength\n" );
}
{ //::osg::Plane::dotProductNormal
typedef float ( ::osg::Plane::*dotProductNormal_function_type)( ::osg::Vec3f const & ) const;
Plane_exposer.def(
"dotProductNormal"
, dotProductNormal_function_type( &::osg::Plane::dotProductNormal )
, ( bp::arg("v") )
, "\n calculate the dot product of the plane normal and a point.\n" );
}
{ //::osg::Plane::dotProductNormal
typedef double ( ::osg::Plane::*dotProductNormal_function_type)( ::osg::Vec3d const & ) const;
Plane_exposer.def(
"dotProductNormal"
, dotProductNormal_function_type( &::osg::Plane::dotProductNormal )
, ( bp::arg("v") )
, "\n calculate the dot product of the plane normal and a point.\n" );
}
{ //::osg::Plane::flip
typedef void ( ::osg::Plane::*flip_function_type)( ) ;
Plane_exposer.def(
"flip"
, flip_function_type( &::osg::Plane::flip )
, "\n flip/reverse the orientation of the plane.\n" );
}
{ //::osg::Plane::getNormal
typedef ::osg::Vec3d ( ::osg::Plane::*getNormal_function_type)( ) const;
Plane_exposer.def(
"getNormal"
, getNormal_function_type( &::osg::Plane::getNormal ) );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::std::vector< osg::Vec3f > const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("vertices") )
, "\n intersection test between plane and vertex list\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::std::vector< osg::Vec3d > const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("vertices") )
, "\n intersection test between plane and vertex list\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::osg::BoundingSphere const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("bs") )
, "\n intersection test between plane and bounding sphere.\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::intersect
typedef int ( ::osg::Plane::*intersect_function_type)( ::osg::BoundingBox const & ) const;
Plane_exposer.def(
"intersect"
, intersect_function_type( &::osg::Plane::intersect )
, ( bp::arg("bb") )
, "\n intersection test between plane and bounding sphere.\n return 1 if the bs is completely above plane,\n return 0 if the bs intersects the plane,\n return -1 if the bs is completely below the plane.\n" );
}
{ //::osg::Plane::isNaN
typedef bool ( ::osg::Plane::*isNaN_function_type)( ) const;
Plane_exposer.def(
"isNaN"
, isNaN_function_type( &::osg::Plane::isNaN ) );
}
{ //::osg::Plane::makeUnitLength
typedef void ( ::osg::Plane::*makeUnitLength_function_type)( ) ;
Plane_exposer.def(
"makeUnitLength"
, makeUnitLength_function_type( &::osg::Plane::makeUnitLength )
, "\n This method multiplies the coefficients of the plane equation with a constant factor so that the\n equation a^2+b^2+c^2 = 1 holds.\n" );
}
Plane_exposer.def( bp::self != bp::self );
Plane_exposer.def( bp::self < bp::self );
{ //::osg::Plane::operator=
typedef ::osg::Plane & ( ::osg::Plane::*assign_function_type)( ::osg::Plane const & ) ;
Plane_exposer.def(
"assign"
, assign_function_type( &::osg::Plane::operator= )
, ( bp::arg("pl") )
, bp::return_self< >() );
}
Plane_exposer.def( bp::self == bp::self );
{ //::osg::Plane::operator[]
typedef double & ( ::osg::Plane::*__getitem___function_type)( unsigned int ) ;
Plane_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Plane::operator[] )
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::osg::Plane::operator[]
typedef double ( ::osg::Plane::*__getitem___function_type)( unsigned int ) const;
Plane_exposer.def(
"__getitem__"
, __getitem___function_type( &::osg::Plane::operator[] )
, ( bp::arg("i") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Plane const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("pl") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( double,double,double,double ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("a"), bp::arg("b"), bp::arg("c"), bp::arg("d") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec4f const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("vec") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec4d const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("vec") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec3d const &,double ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("norm"), bp::arg("d") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec3d const &,::osg::Vec3d const &,::osg::Vec3d const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("v1"), bp::arg("v2"), bp::arg("v3") ) );
}
{ //::osg::Plane::set
typedef void ( ::osg::Plane::*set_function_type)( ::osg::Vec3d const &,::osg::Vec3d const & ) ;
Plane_exposer.def(
"set"
, set_function_type( &::osg::Plane::set )
, ( bp::arg("norm"), bp::arg("point") ) );
}
{ //::osg::Plane::transform
typedef void ( ::osg::Plane::*transform_function_type)( ::osg::Matrix const & ) ;
Plane_exposer.def(
"transform"
, transform_function_type( &::osg::Plane::transform )
, ( bp::arg("matrix") )
, "\n Transform the plane by matrix. Note, this operation carries out\n the calculation of the inverse of the matrix since a plane\n must be multiplied by the inverse transposed to transform it. This\n make this operation expensive. If the inverse has been already\n calculated elsewhere then use transformProvidingInverse() instead.\n See http://www.worldserver.com/turk/computergraphics/NormalTransformations.pdf\n" );
}
{ //::osg::Plane::transformProvidingInverse
typedef void ( ::osg::Plane::*transformProvidingInverse_function_type)( ::osg::Matrix const & ) ;
Plane_exposer.def(
"transformProvidingInverse"
, transformProvidingInverse_function_type( &::osg::Plane::transformProvidingInverse )
, ( bp::arg("matrix") )
, "\n Transform the plane by providing a pre inverted matrix.\n see transform for details.\n" );
}
{ //::osg::Plane::valid
typedef bool ( ::osg::Plane::*valid_function_type)( ) const;
Plane_exposer.def(
"valid"
, valid_function_type( &::osg::Plane::valid )
, "\n Checks if all internal values describing the plane have valid numbers\n Warning: This method does not check if the plane is mathematically correctly described!\n @remark The only case where all elements have valid numbers and the plane description is invalid occurs if the planes normal\n is zero.\n" );
}
Plane_exposer.def( bp::self_ns::str( bp::self ) );
}
}
