void register_Mover_ViewsOfMol__class(){
{ //::SireMol::Mover< SireMol::ViewsOfMol >
typedef bp::class_< SireMol::Mover< SireMol::ViewsOfMol >, bp::bases< SireMol::MoverBase, SireMol::ViewsOfMol, SireMol::MoleculeView, SireBase::Property > > Mover_ViewsOfMol__exposer_t;
Mover_ViewsOfMol__exposer_t Mover_ViewsOfMol__exposer = Mover_ViewsOfMol__exposer_t( "Mover_ViewsOfMol_", bp::init< >() );
bp::scope Mover_ViewsOfMol__scope( Mover_ViewsOfMol__exposer );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("view") )) );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const &, SireMol::AtomSelection const & >(( bp::arg("view"), bp::arg("movable_atoms") )) );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::Mover< SireMol::ViewsOfMol > const & >(( bp::arg("other") )) );
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("angle"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("dihedral"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("improper"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame );
Mover_ViewsOfMol__exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::commit
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::ViewsOfMol ( ::SireMol::Mover< SireMol::ViewsOfMol >::*commit_function_type )( ) const;
commit_function_type commit_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::commit );
Mover_ViewsOfMol__exposer.def(
"commit"
, commit_function_value );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::mapInto
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*mapInto_function_type )( ::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::mapInto );
Mover_ViewsOfMol__exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::operator=
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::Mover< SireMol::ViewsOfMol > const & ) ;
assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= );
Mover_ViewsOfMol__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::operator=
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::ViewsOfMol const & ) ;
assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= );
Mover_ViewsOfMol__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::rotate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate );
Mover_ViewsOfMol__exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::rotate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate );
Mover_ViewsOfMol__exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("bond"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("angle"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("improper"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::setAll
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*setAll_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
setAll_function_type setAll_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::setAll );
Mover_ViewsOfMol__exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::toString
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::QString ( ::SireMol::Mover< SireMol::ViewsOfMol >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::toString );
Mover_ViewsOfMol__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::transform
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*transform_function_type )( ::SireMaths::Transform const &,::SireBase::PropertyMap const & ) ;
transform_function_type transform_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::transform );
Mover_ViewsOfMol__exposer.def(
"transform"
, transform_function_value
, ( bp::arg("transform"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::translate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*translate_function_type )( ::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
translate_function_type translate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::translate );
Mover_ViewsOfMol__exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::typeName
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::typeName );
Mover_ViewsOfMol__exposer.def(
"typeName"
, typeName_function_value );
}
Mover_ViewsOfMol__exposer.staticmethod( "typeName" );
Mover_ViewsOfMol__exposer.def( "__copy__", &__copy__);
Mover_ViewsOfMol__exposer.def( "__deepcopy__", &__copy__);
Mover_ViewsOfMol__exposer.def( "clone", &__copy__);
Mover_ViewsOfMol__exposer.def( "__str__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > );
Mover_ViewsOfMol__exposer.def( "__repr__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > );
Mover_ViewsOfMol__exposer.def( "__len__", &__len_count< ::SireMol::Mover<SireMol::ViewsOfMol> > );
}
}
void register_CoordGroupArray_class(){
{ //::SireVol::CoordGroupArray
typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t;
CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope CoordGroupArray_scope( CoordGroupArray_exposer );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") );
CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") );
CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireVol::CoordGroupArray::aaBox
typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const;
aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox );
CoordGroupArray_exposer.def(
"aaBox"
, aaBox_function_value
, "Return an AABox that complete encompasses all of the CoordGroups\nin this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroup") )
, "Append the passed CoordGroup onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroups") )
, "Append the passed CoordGroups onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordGroup
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const;
assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup );
CoordGroupArray_exposer.def(
"assertValidCoordGroup"
, assertValidCoordGroup_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordinate
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const;
assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate );
CoordGroupArray_exposer.def(
"assertValidCoordinate"
, assertValidCoordinate_function_value
, ( bp::arg("i") )
, "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidIndex
typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex );
CoordGroupArray_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::at
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const;
at_function_type at_function_value( &::SireVol::CoordGroupArray::at );
CoordGroupArray_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::count
typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const;
count_function_type count_function_value( &::SireVol::CoordGroupArray::count );
CoordGroupArray_exposer.def(
"count"
, count_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::isEmpty
typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty );
CoordGroupArray_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this array is empty" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes") )
, "Map all of the coordinates in this array into the coordinate\nframe represented by axes" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("i"), bp::arg("axes") )
, "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::merge
typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge );
CoordGroupArray_exposer.def(
"merge"
, merge_function_value
, "Merge this array of CoordGroups back into a single CoordGroup" );
}
{ //::SireVol::CoordGroupArray::nCoordGroups
typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const;
nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups );
CoordGroupArray_exposer.def(
"nCoordGroups"
, nCoordGroups_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::nCoords
typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const;
nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords );
CoordGroupArray_exposer.def(
"nCoords"
, nCoords_function_value
, "Return the number of coordinates in this array" );
}
CoordGroupArray_exposer.def( bp::self != bp::self );
{ //::SireVol::CoordGroupArray::operator=
typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ;
assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= );
CoordGroupArray_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CoordGroupArray_exposer.def( bp::self == bp::self );
{ //::SireVol::CoordGroupArray::operator[]
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] );
CoordGroupArray_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, "Remove the ith CoordGroup from the array" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") )
, "Remove count CoordGroups from the array, starting with the ith CoordGroup" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("idxs") )
, "Remove the specified CoordGroups from the array" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::size
typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const;
size_function_type size_function_value( &::SireVol::CoordGroupArray::size );
CoordGroupArray_exposer.def(
"size"
, size_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::toString
typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString );
CoordGroupArray_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this array" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("t") )
, "Transform all of coordinates in this array using the transformation t" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("i"), bp::arg("t") )
, "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate all of the coordinates in this array by delta" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("i"), bp::arg("delta") )
, "Translate all of the coordinates in the ith CoordGroup by delta" );
}
{ //::SireVol::CoordGroupArray::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
CoordGroupArray_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("cgroup") )
, "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords") )
, "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
, "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::what
typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
CoordGroupArray_exposer.def(
"what"
, what_function_value
, "" );
}
CoordGroupArray_exposer.staticmethod( "typeName" );
CoordGroupArray_exposer.def( "__copy__", &__copy__);
CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
CoordGroupArray_exposer.def( "clone", &__copy__);
CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
}
}
void register_NullGrid_class(){
{ //::SireVol::NullGrid
typedef bp::class_< SireVol::NullGrid, bp::bases< SireVol::Grid, SireBase::Property > > NullGrid_exposer_t;
NullGrid_exposer_t NullGrid_exposer = NullGrid_exposer_t( "NullGrid", bp::init< >() );
bp::scope NullGrid_scope( NullGrid_exposer );
NullGrid_exposer.def( bp::init< SireVol::NullGrid const & >(( bp::arg("other") )) );
NullGrid_exposer.def( bp::self != bp::self );
{ //::SireVol::NullGrid::operator=
typedef ::SireVol::NullGrid & ( ::SireVol::NullGrid::*assign_function_type )( ::SireVol::NullGrid const & ) ;
assign_function_type assign_function_value( &::SireVol::NullGrid::operator= );
NullGrid_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullGrid_exposer.def( bp::self == bp::self );
{ //::SireVol::NullGrid::recenter
typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*recenter_function_type )( ::SireMaths::Vector const & ) const;
recenter_function_type recenter_function_value( &::SireVol::NullGrid::recenter );
NullGrid_exposer.def(
"recenter"
, recenter_function_value
, ( bp::arg("center") ) );
}
{ //::SireVol::NullGrid::rotate
typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) const;
rotate_function_type rotate_function_value( &::SireVol::NullGrid::rotate );
NullGrid_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("center")=SireMaths::Vector(0.0) ) );
}
{ //::SireVol::NullGrid::rotate
typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) const;
rotate_function_type rotate_function_value( &::SireVol::NullGrid::rotate );
NullGrid_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("center")=SireMaths::Vector(0.0) ) );
}
{ //::SireVol::NullGrid::scale
typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*scale_function_type )( double ) const;
scale_function_type scale_function_value( &::SireVol::NullGrid::scale );
NullGrid_exposer.def(
"scale"
, scale_function_value
, ( bp::arg("scalefactor") ) );
}
{ //::SireVol::NullGrid::translate
typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*translate_function_type )( ::SireMaths::Vector const & ) const;
translate_function_type translate_function_value( &::SireVol::NullGrid::translate );
NullGrid_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") ) );
}
{ //::SireVol::NullGrid::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::NullGrid::typeName );
NullGrid_exposer.def(
"typeName"
, typeName_function_value );
}
NullGrid_exposer.staticmethod( "typeName" );
NullGrid_exposer.def( "__copy__", &__copy__);
NullGrid_exposer.def( "__deepcopy__", &__copy__);
NullGrid_exposer.def( "clone", &__copy__);
NullGrid_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::NullGrid >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullGrid_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::NullGrid >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullGrid_exposer.def( "__str__", &__str__< ::SireVol::NullGrid > );
NullGrid_exposer.def( "__repr__", &__str__< ::SireVol::NullGrid > );
NullGrid_exposer.def( "__len__", &__len_count< ::SireVol::NullGrid > );
}
}
void register_AABox_class(){
{ //::SireVol::AABox
typedef bp::class_< SireVol::AABox > AABox_exposer_t;
AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", "\nAn AABox is an axis-aligned bounding box that is the smallest box that is aligned with the three cartesian axes that completely encases a CoordGroup. It is trivial to obtain the bounding sphere from the AABox. The AABox is used by the distance calculators to quickly determine whether two CoordGroups are within the cutoff radius, and to obtain all CoordGroups that are within particular regions of space.\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty AABox") );
bp::scope AABox_scope( AABox_exposer );
AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") ), "Construct an AABox that completely encloses the point point") );
AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") ), "Construct an AABox with center at cent, and half-extents extents") );
AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") ), "Construct an AABox that completely encases the points in coordinates") );
AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") ), "Construct an AABox that completely encases the points in coords") );
AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") ), "Construct an AABox that completely encases the CoordGroup coordgroup") );
AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in cgarray") );
AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") ), "Construct an AABox that completely encases all of the points in all of the\nCoordGroups in all of the arrays in cgarrays") );
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::SireVol::AABox const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") )
, "Add another AABox to this one - this forms the union of both of the\nboxes." );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::SireMaths::Vector const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("point") )
, "Add a point to this box" );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type)( ::QVector< SireMaths::Vector > const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("points") )
, "Add lots of points to this box" );
}
{ //::SireVol::AABox::boundingSphere
typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type)( ) const;
boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere );
AABox_exposer.def(
"boundingSphere"
, boundingSphere_function_value
, "Return the sphere that just contains this AABox" );
}
{ //::SireVol::AABox::center
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type)( ) const;
center_function_type center_function_value( &::SireVol::AABox::center );
AABox_exposer.def(
"center"
, center_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireVol::AABox const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("other") )
, "Return whether or not this box contains other" );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type)( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") )
, "Return whether or not this box contains the point point" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("point") )
, "Return an AABox constructed to contain the coordinates of point" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coordgroup") )
, "Return an AABox constructed to contain the coordinates in coordinates" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarray") )
, "Return an AABox constructed to contain all of the CoordGroups in cgarray" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarrays") )
, "Return an AABox constructed to contain all of the CoordGroups in the\narrays in cgarrays" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coords") )
, "Return an AABox constructed to contain the coordinates in coordinates" );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("mincoords"), bp::arg("maxcoords") )
, "Construct a new AABox from the passed minimum and maximum coordinates" );
}
{ //::SireVol::AABox::halfExtents
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type)( ) const;
halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents );
AABox_exposer.def(
"halfExtents"
, halfExtents_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::AABox::intersects
typedef bool ( ::SireVol::AABox::*intersects_function_type)( ::SireVol::AABox const & ) const;
intersects_function_type intersects_function_value( &::SireVol::AABox::intersects );
AABox_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") )
, "Return whether this box intersects with box" );
}
{ //::SireVol::AABox::isEmpty
typedef bool ( ::SireVol::AABox::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty );
AABox_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return if the AABox is empty" );
}
{ //::SireVol::AABox::isNull
typedef bool ( ::SireVol::AABox::*isNull_function_type)( ) const;
isNull_function_type isNull_function_value( &::SireVol::AABox::isNull );
AABox_exposer.def(
"isNull"
, isNull_function_value
, "Return if the AABox is null" );
}
{ //::SireVol::AABox::maxCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type)( ) const;
maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords );
AABox_exposer.def(
"maxCoords"
, maxCoords_function_value
, "" );
}
{ //::SireVol::AABox::minCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type)( ) const;
minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords );
AABox_exposer.def(
"minCoords"
, minCoords_function_value
, "" );
}
AABox_exposer.def( bp::self != bp::self );
AABox_exposer.def( bp::self + bp::self );
AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() );
{ //::SireVol::AABox::operator=
typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type)( ::SireVol::AABox const & ) ;
assign_function_type assign_function_value( &::SireVol::AABox::operator= );
AABox_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
AABox_exposer.def( bp::self == bp::self );
{ //::SireVol::AABox::radius
typedef double ( ::SireVol::AABox::*radius_function_type)( ) const;
radius_function_type radius_function_value( &::SireVol::AABox::radius );
AABox_exposer.def(
"radius"
, radius_function_value
, "" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupBase const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordgroup") )
, "Recalculate the AABox so that it completely encloses the CoordGroup coordgroup" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarray") )
, "Recalculate the AABox so that it completely encloses the CoordGroups\nin the array cgarray" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::SireVol::CoordGroupArrayArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarrays") )
, "Recalculate the AABox so that it completely encloses the CoordGroups\nin the arrays cgarrays" );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type)( ::QVector< SireMaths::Vector > const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordinates") )
, "Recalculate the AABox so that it completely encloses the coordinates" );
}
{ //::SireVol::AABox::toString
typedef ::QString ( ::SireVol::AABox::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::AABox::toString );
AABox_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this AABox" );
}
{ //::SireVol::AABox::translate
typedef void ( ::SireVol::AABox::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::AABox::translate );
AABox_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate this AABox by delta" );
}
{ //::SireVol::AABox::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::AABox::typeName );
AABox_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::AABox::what
typedef char const * ( ::SireVol::AABox::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::AABox::what );
AABox_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireVol::AABox::withinDistance
typedef bool ( ::SireVol::AABox::*withinDistance_function_type)( double,::SireVol::AABox const & ) const;
withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance );
AABox_exposer.def(
"withinDistance"
, withinDistance_function_value
, ( bp::arg("dist"), bp::arg("box") )
, "Return whether or not this box is within dist of box box.\n(using infinite cartesian axes)" );
}
AABox_exposer.staticmethod( "from" );
AABox_exposer.staticmethod( "typeName" );
AABox_exposer.def( "__copy__", &__copy__);
AABox_exposer.def( "__deepcopy__", &__copy__);
AABox_exposer.def( "clone", &__copy__);
AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > );
AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > );
}
}
void register_Sphere_class(){
{ //::SireMaths::Sphere
typedef bp::class_< SireMaths::Sphere > Sphere_exposer_t;
Sphere_exposer_t Sphere_exposer = Sphere_exposer_t( "Sphere", bp::init< >() );
bp::scope Sphere_scope( Sphere_exposer );
Sphere_exposer.def( bp::init< double const & >(( bp::arg("radius") )) );
Sphere_exposer.def( bp::init< SireMaths::Vector const &, double const & >(( bp::arg("position"), bp::arg("radius") )) );
Sphere_exposer.def( bp::init< SireMaths::Sphere const & >(( bp::arg("other") )) );
{ //::SireMaths::Sphere::center
typedef ::SireMaths::Vector const & ( ::SireMaths::Sphere::*center_function_type )( ) const;
center_function_type center_function_value( &::SireMaths::Sphere::center );
Sphere_exposer.def(
"center"
, center_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Sphere::combinedVolume
typedef double ( *combinedVolume_function_type )( ::QVector< SireMaths::Sphere > const & );
combinedVolume_function_type combinedVolume_function_value( &::SireMaths::Sphere::combinedVolume );
Sphere_exposer.def(
"combinedVolume"
, combinedVolume_function_value
, ( bp::arg("spheres") ) );
}
{ //::SireMaths::Sphere::combinedVolumeMC
typedef double ( *combinedVolumeMC_function_type )( ::QVector< SireMaths::Sphere > const &,qint64 );
combinedVolumeMC_function_type combinedVolumeMC_function_value( &::SireMaths::Sphere::combinedVolumeMC );
Sphere_exposer.def(
"combinedVolumeMC"
, combinedVolumeMC_function_value
, ( bp::arg("spheres"), bp::arg("nsamples")=(qint64)(-0x00000000000000001) ) );
}
{ //::SireMaths::Sphere::contains
typedef bool ( ::SireMaths::Sphere::*contains_function_type )( ::SireMaths::Sphere const & ) const;
contains_function_type contains_function_value( &::SireMaths::Sphere::contains );
Sphere_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("other") ) );
}
{ //::SireMaths::Sphere::intersectionVolume
typedef double ( ::SireMaths::Sphere::*intersectionVolume_function_type )( ::SireMaths::Sphere const & ) const;
intersectionVolume_function_type intersectionVolume_function_value( &::SireMaths::Sphere::intersectionVolume );
Sphere_exposer.def(
"intersectionVolume"
, intersectionVolume_function_value
, ( bp::arg("other") ) );
}
{ //::SireMaths::Sphere::intersectionVolume
typedef double ( ::SireMaths::Sphere::*intersectionVolume_function_type )( ::SireMaths::Sphere const &,::SireMaths::Sphere const & ) const;
intersectionVolume_function_type intersectionVolume_function_value( &::SireMaths::Sphere::intersectionVolume );
Sphere_exposer.def(
"intersectionVolume"
, intersectionVolume_function_value
, ( bp::arg("other0"), bp::arg("other1") ) );
}
{ //::SireMaths::Sphere::intersects
typedef bool ( ::SireMaths::Sphere::*intersects_function_type )( ::SireMaths::Sphere const & ) const;
intersects_function_type intersects_function_value( &::SireMaths::Sphere::intersects );
Sphere_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
Sphere_exposer.def( bp::self != bp::self );
Sphere_exposer.def( bp::self == bp::self );
{ //::SireMaths::Sphere::position
typedef ::SireMaths::Vector const & ( ::SireMaths::Sphere::*position_function_type )( ) const;
position_function_type position_function_value( &::SireMaths::Sphere::position );
Sphere_exposer.def(
"position"
, position_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Sphere::radius
typedef double ( ::SireMaths::Sphere::*radius_function_type )( ) const;
radius_function_type radius_function_value( &::SireMaths::Sphere::radius );
Sphere_exposer.def(
"radius"
, radius_function_value );
}
{ //::SireMaths::Sphere::setCenter
typedef void ( ::SireMaths::Sphere::*setCenter_function_type )( ::SireMaths::Vector const & ) ;
setCenter_function_type setCenter_function_value( &::SireMaths::Sphere::setCenter );
Sphere_exposer.def(
"setCenter"
, setCenter_function_value
, ( bp::arg("center") ) );
}
{ //::SireMaths::Sphere::setPosition
typedef void ( ::SireMaths::Sphere::*setPosition_function_type )( ::SireMaths::Vector const & ) ;
setPosition_function_type setPosition_function_value( &::SireMaths::Sphere::setPosition );
Sphere_exposer.def(
"setPosition"
, setPosition_function_value
, ( bp::arg("position") ) );
}
{ //::SireMaths::Sphere::setRadius
typedef void ( ::SireMaths::Sphere::*setRadius_function_type )( double ) ;
setRadius_function_type setRadius_function_value( &::SireMaths::Sphere::setRadius );
Sphere_exposer.def(
"setRadius"
, setRadius_function_value
, ( bp::arg("radius") ) );
}
{ //::SireMaths::Sphere::surfaceArea
typedef double ( ::SireMaths::Sphere::*surfaceArea_function_type )( ) const;
surfaceArea_function_type surfaceArea_function_value( &::SireMaths::Sphere::surfaceArea );
Sphere_exposer.def(
"surfaceArea"
, surfaceArea_function_value );
}
{ //::SireMaths::Sphere::toString
typedef ::QString ( ::SireMaths::Sphere::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMaths::Sphere::toString );
Sphere_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMaths::Sphere::translate
typedef ::SireMaths::Sphere ( ::SireMaths::Sphere::*translate_function_type )( ::SireMaths::Vector const & ) const;
translate_function_type translate_function_value( &::SireMaths::Sphere::translate );
Sphere_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") ) );
}
{ //::SireMaths::Sphere::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::Sphere::typeName );
Sphere_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMaths::Sphere::volume
typedef double ( ::SireMaths::Sphere::*volume_function_type )( ) const;
volume_function_type volume_function_value( &::SireMaths::Sphere::volume );
Sphere_exposer.def(
"volume"
, volume_function_value );
}
{ //::SireMaths::Sphere::what
typedef char const * ( ::SireMaths::Sphere::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMaths::Sphere::what );
Sphere_exposer.def(
"what"
, what_function_value );
}
Sphere_exposer.staticmethod( "combinedVolume" );
Sphere_exposer.staticmethod( "combinedVolumeMC" );
Sphere_exposer.staticmethod( "typeName" );
Sphere_exposer.def( "__copy__", &__copy__);
Sphere_exposer.def( "__deepcopy__", &__copy__);
Sphere_exposer.def( "clone", &__copy__);
Sphere_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Sphere >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Sphere_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Sphere >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Sphere_exposer.def( "__str__", &__str__< ::SireMaths::Sphere > );
Sphere_exposer.def( "__repr__", &__str__< ::SireMaths::Sphere > );
}
}
void register_AABox_class(){
{ //::SireVol::AABox
typedef bp::class_< SireVol::AABox > AABox_exposer_t;
AABox_exposer_t AABox_exposer = AABox_exposer_t( "AABox", bp::init< >() );
bp::scope AABox_scope( AABox_exposer );
AABox_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") )) );
AABox_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Vector const & >(( bp::arg("cent"), bp::arg("extents") )) );
AABox_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("coordinates") )) );
AABox_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("coords"), bp::arg("ncoords") )) );
AABox_exposer.def( bp::init< SireVol::CoordGroupBase const & >(( bp::arg("coordgroup") )) );
AABox_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgarray") )) );
AABox_exposer.def( bp::init< SireVol::CoordGroupArrayArray const & >(( bp::arg("cgarrays") )) );
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type )( ::SireVol::AABox const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") ) );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type )( ::SireMaths::Vector const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::AABox::add
typedef void ( ::SireVol::AABox::*add_function_type )( ::QVector< SireMaths::Vector > const & ) ;
add_function_type add_function_value( &::SireVol::AABox::add );
AABox_exposer.def(
"add"
, add_function_value
, ( bp::arg("points") ) );
}
{ //::SireVol::AABox::boundingSphere
typedef ::SireMaths::Sphere ( ::SireVol::AABox::*boundingSphere_function_type )( ) const;
boundingSphere_function_type boundingSphere_function_value( &::SireVol::AABox::boundingSphere );
AABox_exposer.def(
"boundingSphere"
, boundingSphere_function_value );
}
{ //::SireVol::AABox::center
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*center_function_type )( ) const;
center_function_type center_function_value( &::SireVol::AABox::center );
AABox_exposer.def(
"center"
, center_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type )( ::SireVol::AABox const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("other") ) );
}
{ //::SireVol::AABox::contains
typedef bool ( ::SireVol::AABox::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::AABox::contains );
AABox_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupBase const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coordgroup") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarray") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireVol::CoordGroupArrayArray const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("cgarrays") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::QVector< SireMaths::Vector > const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("coords") ) );
}
{ //::SireVol::AABox::from
typedef ::SireVol::AABox ( *from_function_type )( ::SireMaths::Vector const &,::SireMaths::Vector const & );
from_function_type from_function_value( &::SireVol::AABox::from );
AABox_exposer.def(
"from"
, from_function_value
, ( bp::arg("mincoords"), bp::arg("maxcoords") ) );
}
{ //::SireVol::AABox::halfExtents
typedef ::SireMaths::Vector const & ( ::SireVol::AABox::*halfExtents_function_type )( ) const;
halfExtents_function_type halfExtents_function_value( &::SireVol::AABox::halfExtents );
AABox_exposer.def(
"halfExtents"
, halfExtents_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireVol::AABox::intersects
typedef bool ( ::SireVol::AABox::*intersects_function_type )( ::SireVol::AABox const & ) const;
intersects_function_type intersects_function_value( &::SireVol::AABox::intersects );
AABox_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("other") ) );
}
{ //::SireVol::AABox::isEmpty
typedef bool ( ::SireVol::AABox::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::AABox::isEmpty );
AABox_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::AABox::isNull
typedef bool ( ::SireVol::AABox::*isNull_function_type )( ) const;
isNull_function_type isNull_function_value( &::SireVol::AABox::isNull );
AABox_exposer.def(
"isNull"
, isNull_function_value );
}
{ //::SireVol::AABox::maxCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*maxCoords_function_type )( ) const;
maxCoords_function_type maxCoords_function_value( &::SireVol::AABox::maxCoords );
AABox_exposer.def(
"maxCoords"
, maxCoords_function_value );
}
{ //::SireVol::AABox::minCoords
typedef ::SireMaths::Vector ( ::SireVol::AABox::*minCoords_function_type )( ) const;
minCoords_function_type minCoords_function_value( &::SireVol::AABox::minCoords );
AABox_exposer.def(
"minCoords"
, minCoords_function_value );
}
AABox_exposer.def( bp::self != bp::self );
AABox_exposer.def( bp::self + bp::self );
AABox_exposer.def( bp::self + bp::other< SireMaths::Vector >() );
AABox_exposer.def( bp::self + bp::other< QVector< SireMaths::Vector > >() );
{ //::SireVol::AABox::operator=
typedef ::SireVol::AABox const & ( ::SireVol::AABox::*assign_function_type )( ::SireVol::AABox const & ) ;
assign_function_type assign_function_value( &::SireVol::AABox::operator= );
AABox_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
AABox_exposer.def( bp::self == bp::self );
{ //::SireVol::AABox::radius
typedef double ( ::SireVol::AABox::*radius_function_type )( ) const;
radius_function_type radius_function_value( &::SireVol::AABox::radius );
AABox_exposer.def(
"radius"
, radius_function_value );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupBase const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordgroup") ) );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarray") ) );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::SireVol::CoordGroupArrayArray const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("cgarrays") ) );
}
{ //::SireVol::AABox::recalculate
typedef void ( ::SireVol::AABox::*recalculate_function_type )( ::QVector< SireMaths::Vector > const & ) ;
recalculate_function_type recalculate_function_value( &::SireVol::AABox::recalculate );
AABox_exposer.def(
"recalculate"
, recalculate_function_value
, ( bp::arg("coordinates") ) );
}
{ //::SireVol::AABox::toString
typedef ::QString ( ::SireVol::AABox::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::AABox::toString );
AABox_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::AABox::translate
typedef void ( ::SireVol::AABox::*translate_function_type )( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::AABox::translate );
AABox_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") ) );
}
{ //::SireVol::AABox::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::AABox::typeName );
AABox_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::AABox::what
typedef char const * ( ::SireVol::AABox::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::AABox::what );
AABox_exposer.def(
"what"
, what_function_value );
}
{ //::SireVol::AABox::withinDistance
typedef bool ( ::SireVol::AABox::*withinDistance_function_type )( double,::SireVol::AABox const & ) const;
withinDistance_function_type withinDistance_function_value( &::SireVol::AABox::withinDistance );
AABox_exposer.def(
"withinDistance"
, withinDistance_function_value
, ( bp::arg("dist"), bp::arg("box") ) );
}
AABox_exposer.staticmethod( "from" );
AABox_exposer.staticmethod( "typeName" );
AABox_exposer.def( "__copy__", &__copy__);
AABox_exposer.def( "__deepcopy__", &__copy__);
AABox_exposer.def( "clone", &__copy__);
AABox_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::AABox >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AABox_exposer.def( "__str__", &__str__< ::SireVol::AABox > );
AABox_exposer.def( "__repr__", &__str__< ::SireVol::AABox > );
}
}
void register_AtomCoords_class(){
{ //::SireMol::AtomProperty< SireMaths::Vector >
typedef bp::class_< SireMol::AtomProperty< SireMaths::Vector >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomCoords_exposer_t;
AtomCoords_exposer_t AtomCoords_exposer = AtomCoords_exposer_t( "AtomCoords", bp::init< >() );
bp::scope AtomCoords_scope( AtomCoords_exposer );
AtomCoords_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
AtomCoords_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") )) );
AtomCoords_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgroups") )) );
AtomCoords_exposer.def( bp::init< SireMol::AtomProperty< SireMaths::Vector > const & >(( bp::arg("other") )) );
{ //::SireMol::AtomProperty< SireMaths::Vector >::array
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroupArray const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*array_function_type )( ) const;
array_function_type array_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::array );
AtomCoords_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assertCanConvert_function_type )( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert );
AtomCoords_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::assignFrom
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assignFrom_function_type )( ::SireMol::AtomProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assignFrom );
AtomCoords_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::at
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGIdx ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
AtomCoords_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::at
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGAtomIdx const & ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
AtomCoords_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::canConvert
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*canConvert_function_type )( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::canConvert );
AtomCoords_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
AtomCoords_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
AtomCoords_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("cgidx"), bp::arg("from_frame"), bp::arg("to_frame") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
AtomCoords_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const &,::SireMol::AtomSelection const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
AtomCoords_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values"), bp::arg("selection") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::count
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::count );
AtomCoords_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::divide
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divide_function_type )( ::QVector< SireMol::AtomSelection > const & ) const;
divide_function_type divide_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divide );
AtomCoords_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("beads") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divideByResidue_function_type )( ::SireMol::MoleculeInfoData const & ) const;
divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue );
AtomCoords_exposer.def(
"divideByResidue"
, divideByResidue_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::fromVariant
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::fromVariant );
AtomCoords_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::get
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGIdx ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
AtomCoords_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::get
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGAtomIdx const & ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
AtomCoords_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith );
AtomCoords_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
AtomCoords_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
AtomCoords_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("cgidx"), bp::arg("axes") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::merge
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*merge_function_type )( ::SireMol::MoleculeInfoData const & ) const;
merge_function_type merge_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::merge );
AtomCoords_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
AtomCoords_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ::SireMol::CGIdx ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
AtomCoords_exposer.def(
"nAtoms"
, nAtoms_function_value
, ( bp::arg("cgidx") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nCutGroups_function_type )( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups );
AtomCoords_exposer.def(
"nCutGroups"
, nCutGroups_function_value );
}
AtomCoords_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomProperty< SireMaths::Vector >::operator=
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*assign_function_type )( ::SireMol::AtomProperty< SireMaths::Vector > const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator= );
AtomCoords_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
AtomCoords_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGIdx ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
AtomCoords_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGAtomIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
AtomCoords_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("cgidx"), bp::arg("quat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("cgidx"), bp::arg("rotmat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::set
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGAtomIdx const &,::SireMaths::Vector const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
AtomCoords_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgatomidx"), bp::arg("value") )
, bp::return_self< >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::set
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::QVector< SireMaths::Vector > const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
AtomCoords_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("values") )
, bp::return_self< >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::set
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::SireVol::CoordGroup const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
AtomCoords_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("cgroup") )
, bp::return_self< >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::size
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::size );
AtomCoords_exposer.def(
"size"
, size_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::toVariant
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVariant );
AtomCoords_exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::toVector
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
AtomCoords_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::toVector
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
AtomCoords_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::transform
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
AtomCoords_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("t") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::transform
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMol::CGIdx,::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
AtomCoords_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("cgidx"), bp::arg("t") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::translate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
AtomCoords_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::translate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMol::CGIdx,::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
AtomCoords_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("cgidx"), bp::arg("delta") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::typeName
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::typeName );
AtomCoords_exposer.def(
"typeName"
, typeName_function_value );
}
AtomCoords_exposer.staticmethod( "fromVariant" );
AtomCoords_exposer.staticmethod( "typeName" );
AtomCoords_exposer.def( "__copy__", &__copy__);
AtomCoords_exposer.def( "__deepcopy__", &__copy__);
AtomCoords_exposer.def( "clone", &__copy__);
AtomCoords_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomCoords_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomCoords_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
AtomCoords_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
AtomCoords_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<SireMaths::Vector> > );
}
}
