// This file has been generated by Py++.

#include "boost/python.hpp"
#include "__call_policies.pypp.hpp"
#include "opencv_converters.hpp"
#include "__ctypes_integration.pypp.hpp"
#include "opencv_headers.hpp"
#include "SpinImageModel.pypp.hpp"

namespace bp = boost::python;

static boost::python::object match_86773a6b4d89ae97806d1109a2438811( ::cv::SpinImageModel & inst, ::cv::SpinImageModel const & scene ){
    std::vector<std::vector<cv::Vec<int, 2>, std::allocator<cv::Vec<int, 2> > >, std::allocator<std::vector<cv::Vec<int, 2>, std::allocator<cv::Vec<int, 2> > > > > result3;
    bp::list result4;
    inst.match(scene, result3);
    convert_from_T_to_object(result3, result4);
    return bp::object( result4 );
}

static void setSubset_89bf1b6d328936932f08aaf660288e7a( ::cv::SpinImageModel & inst, cv::Mat const & subset ){
    std::vector<int, std::allocator<int> > subset2;
    convert_from_Mat_to_vector_of_T(subset, subset2);
    inst.setSubset(subset2);
}

void register_SpinImageModel_class(){

    { //::cv::SpinImageModel
        typedef bp::class_< cv::SpinImageModel > SpinImageModel_exposer_t;
        SpinImageModel_exposer_t SpinImageModel_exposer = SpinImageModel_exposer_t( "SpinImageModel", bp::init< >() );
        bp::scope SpinImageModel_scope( SpinImageModel_exposer );
        SpinImageModel_exposer.add_property( "this", pyplus_conv::make_addressof_inst_getter< cv::SpinImageModel >() );
        SpinImageModel_exposer.def( bp::init< cv::Mesh3D const & >(( bp::arg("mesh") )) );
        bp::implicitly_convertible< cv::Mesh3D const &, cv::SpinImageModel >();
        { //::cv::SpinImageModel::compute
        
            typedef void ( ::cv::SpinImageModel::*compute_function_type )(  ) ;
            
            SpinImageModel_exposer.def( 
                "compute"
                , compute_function_type( &::cv::SpinImageModel::compute ) );
        
        }
        { //::cv::SpinImageModel::getMesh
        
            typedef ::cv::Mesh3D const & ( ::cv::SpinImageModel::*getMesh_function_type )(  ) const;
            
            SpinImageModel_exposer.def( 
                "getMesh"
                , getMesh_function_type( &::cv::SpinImageModel::getMesh )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::cv::SpinImageModel::getMesh
        
            typedef ::cv::Mesh3D & ( ::cv::SpinImageModel::*getMesh_function_type )(  ) ;
            
            SpinImageModel_exposer.def( 
                "getMesh"
                , getMesh_function_type( &::cv::SpinImageModel::getMesh )
                , bp::return_internal_reference< >() );
        
        }
        { //::cv::SpinImageModel::getSpinCount
        
            typedef ::size_t ( ::cv::SpinImageModel::*getSpinCount_function_type )(  ) const;
            
            SpinImageModel_exposer.def( 
                "getSpinCount"
                , getSpinCount_function_type( &::cv::SpinImageModel::getSpinCount ) );
        
        }
        { //::cv::SpinImageModel::getSpinImage
        
            typedef ::cv::Mat ( ::cv::SpinImageModel::*getSpinImage_function_type )( ::size_t ) const;
            
            SpinImageModel_exposer.def( 
                "getSpinImage"
                , getSpinImage_function_type( &::cv::SpinImageModel::getSpinImage )
                , ( bp::arg("index") ) );
        
        }
        { //::cv::SpinImageModel::getSpinNormal
        
            typedef ::cv::Point3f const & ( ::cv::SpinImageModel::*getSpinNormal_function_type )( ::size_t ) const;
            
            SpinImageModel_exposer.def( 
                "getSpinNormal"
                , getSpinNormal_function_type( &::cv::SpinImageModel::getSpinNormal )
                , ( bp::arg("index") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::cv::SpinImageModel::getSpinVertex
        
            typedef ::cv::Point3f const & ( ::cv::SpinImageModel::*getSpinVertex_function_type )( ::size_t ) const;
            
            SpinImageModel_exposer.def( 
                "getSpinVertex"
                , getSpinVertex_function_type( &::cv::SpinImageModel::getSpinVertex )
                , ( bp::arg("index") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::cv::SpinImageModel::match
        
            typedef boost::python::object ( *match_function_type )( ::cv::SpinImageModel &,::cv::SpinImageModel const & );
            
            SpinImageModel_exposer.def( 
                "match"
                , match_function_type( &match_86773a6b4d89ae97806d1109a2438811 )
                , ( bp::arg("inst"), bp::arg("scene") )
                , "\nArgument 'result':"\
    "\n    C/C++ type: ::std::vector< std::vector< cv::Vec<int, 2> > > &."\
    "\n    Python type: list of Mat, e.g. [Mat(), Mat(), Mat()]."\
    "\n    Invoke asMat() to convert every 1D Python sequence into a Mat, e.g. "\
    "\n    [asMat([0,1,2]), asMat((0,1,2)]."\
    "\n    Output argument: omitted from the function's calling sequence, and is "\
    "\n    returned along with the function's return value (if any)." );
        
        }
        { //::cv::SpinImageModel::packRandomScaledSpins
        
            typedef ::cv::Mat ( ::cv::SpinImageModel::*packRandomScaledSpins_function_type )( bool,::size_t,::size_t ) const;
            
            SpinImageModel_exposer.def( 
                "packRandomScaledSpins"
                , packRandomScaledSpins_function_type( &::cv::SpinImageModel::packRandomScaledSpins )
                , ( bp::arg("separateScale")=(bool)(false), bp::arg("xCount")=(::size_t)(10), bp::arg("yCount")=(::size_t)(10) ) );
        
        }
        { //::cv::SpinImageModel::selectRandomSubset
        
            typedef void ( ::cv::SpinImageModel::*selectRandomSubset_function_type )( float ) ;
            
            SpinImageModel_exposer.def( 
                "selectRandomSubset"
                , selectRandomSubset_function_type( &::cv::SpinImageModel::selectRandomSubset )
                , ( bp::arg("ratio") ) );
        
        }
        { //::cv::SpinImageModel::setSubset
        
            typedef void ( *setSubset_function_type )( ::cv::SpinImageModel &,cv::Mat const & );
            
            SpinImageModel_exposer.def( 
                "setSubset"
                , setSubset_function_type( &setSubset_89bf1b6d328936932f08aaf660288e7a )
                , ( bp::arg("inst"), bp::arg("subset") )
                , "\nArgument 'subset':"\
    "\n    C/C++ type: ::std::vector< int > const &."\
    "\n    Python type: Mat."\
    "\n    Invoke asMat() to convert a 1D Python sequence into a Mat, e.g. "\
    "\n    asMat([0,1,2]) or asMat((0,1,2))." );
        
        }
        { //::cv::SpinImageModel::spinCorrelation
        
            typedef bool ( *spinCorrelation_function_type )( ::cv::Mat const &,::cv::Mat const &,float,float & );
            
            SpinImageModel_exposer.def( 
                "spinCorrelation"
                , spinCorrelation_function_type( &::cv::SpinImageModel::spinCorrelation )
                , ( bp::arg("spin1"), bp::arg("spin2"), bp::arg("lambda"), bp::arg("result") ) );
        
        }
        SpinImageModel_exposer.def_readwrite( "T_GeometriccConsistency", &cv::SpinImageModel::T_GeometriccConsistency );
        SpinImageModel_exposer.def_readwrite( "T_GroupingCorespondances", &cv::SpinImageModel::T_GroupingCorespondances );
        SpinImageModel_exposer.def_readwrite( "binSize", &cv::SpinImageModel::binSize );
        SpinImageModel_exposer.def_readwrite( "gamma", &cv::SpinImageModel::gamma );
        SpinImageModel_exposer.def_readwrite( "imageWidth", &cv::SpinImageModel::imageWidth );
        SpinImageModel_exposer.def_readwrite( "lambda_", &cv::SpinImageModel::lambda );
        SpinImageModel_exposer.def_readwrite( "minNeighbors", &cv::SpinImageModel::minNeighbors );
        SpinImageModel_exposer.def_readwrite( "normalRadius", &cv::SpinImageModel::normalRadius );
        SpinImageModel_exposer.staticmethod( "spinCorrelation" );
    }

}
