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

#include "boost/python.hpp"
#include "__ctypes_integration.pypp.hpp"
#include "opencv_headers.hpp"
#include "FeatureEvaluator.pypp.hpp"

namespace bp = boost::python;

struct FeatureEvaluator_wrapper : cv::FeatureEvaluator, bp::wrapper< cv::FeatureEvaluator > {

    FeatureEvaluator_wrapper(cv::FeatureEvaluator const & arg )
    : cv::FeatureEvaluator( arg )
      , bp::wrapper< cv::FeatureEvaluator >(){
        // copy constructor
        
    }

    FeatureEvaluator_wrapper()
    : cv::FeatureEvaluator()
      , bp::wrapper< cv::FeatureEvaluator >(){
        // null constructor
        
    }

    virtual int calcCat( int featureIdx ) const  {
        if( bp::override func_calcCat = this->get_override( "calcCat" ) )
            return func_calcCat( featureIdx );
        else{
            return this->cv::FeatureEvaluator::calcCat( featureIdx );
        }
    }
    
    int default_calcCat( int featureIdx ) const  {
        return cv::FeatureEvaluator::calcCat( featureIdx );
    }

    virtual double calcOrd( int featureIdx ) const  {
        if( bp::override func_calcOrd = this->get_override( "calcOrd" ) )
            return func_calcOrd( featureIdx );
        else{
            return this->cv::FeatureEvaluator::calcOrd( featureIdx );
        }
    }
    
    double default_calcOrd( int featureIdx ) const  {
        return cv::FeatureEvaluator::calcOrd( featureIdx );
    }

    virtual ::cv::Ptr< cv::FeatureEvaluator > clone(  ) const  {
        if( bp::override func_clone = this->get_override( "clone" ) )
            return func_clone(  );
        else{
            return this->cv::FeatureEvaluator::clone(  );
        }
    }
    
    ::cv::Ptr< cv::FeatureEvaluator > default_clone(  ) const  {
        return cv::FeatureEvaluator::clone( );
    }

    virtual int getFeatureType(  ) const  {
        if( bp::override func_getFeatureType = this->get_override( "getFeatureType" ) )
            return func_getFeatureType(  );
        else{
            return this->cv::FeatureEvaluator::getFeatureType(  );
        }
    }
    
    int default_getFeatureType(  ) const  {
        return cv::FeatureEvaluator::getFeatureType( );
    }

    virtual bool read( ::cv::FileNode const & node ) {
        if( bp::override func_read = this->get_override( "read" ) )
            return func_read( boost::ref(node) );
        else{
            return this->cv::FeatureEvaluator::read( boost::ref(node) );
        }
    }
    
    bool default_read( ::cv::FileNode const & node ) {
        return cv::FeatureEvaluator::read( boost::ref(node) );
    }

    virtual bool setImage( ::cv::Mat const & arg0, ::cv::Size origWinSize ) {
        if( bp::override func_setImage = this->get_override( "setImage" ) )
            return func_setImage( boost::ref(arg0), origWinSize );
        else{
            return this->cv::FeatureEvaluator::setImage( boost::ref(arg0), origWinSize );
        }
    }
    
    bool default_setImage( ::cv::Mat const & arg0, ::cv::Size origWinSize ) {
        return cv::FeatureEvaluator::setImage( boost::ref(arg0), origWinSize );
    }

    virtual bool setWindow( ::cv::Point p ) {
        if( bp::override func_setWindow = this->get_override( "setWindow" ) )
            return func_setWindow( p );
        else{
            return this->cv::FeatureEvaluator::setWindow( p );
        }
    }
    
    bool default_setWindow( ::cv::Point p ) {
        return cv::FeatureEvaluator::setWindow( p );
    }

};

void register_FeatureEvaluator_class(){

    { //::cv::FeatureEvaluator
        typedef bp::class_< FeatureEvaluator_wrapper > FeatureEvaluator_exposer_t;
        FeatureEvaluator_exposer_t FeatureEvaluator_exposer = FeatureEvaluator_exposer_t( "FeatureEvaluator" );
        bp::scope FeatureEvaluator_scope( FeatureEvaluator_exposer );
        FeatureEvaluator_exposer.add_property( "this", pyplus_conv::make_addressof_inst_getter< cv::FeatureEvaluator >() );
        bp::scope().attr("HAAR") = (int)cv::FeatureEvaluator::HAAR;
        bp::scope().attr("LBP") = (int)cv::FeatureEvaluator::LBP;
        { //::cv::FeatureEvaluator::calcCat
        
            typedef int ( ::cv::FeatureEvaluator::*calcCat_function_type )( int ) const;
            typedef int ( FeatureEvaluator_wrapper::*default_calcCat_function_type )( int ) const;
            
            FeatureEvaluator_exposer.def( 
                "calcCat"
                , calcCat_function_type(&::cv::FeatureEvaluator::calcCat)
                , default_calcCat_function_type(&FeatureEvaluator_wrapper::default_calcCat)
                , ( bp::arg("featureIdx") ) );
        
        }
        { //::cv::FeatureEvaluator::calcOrd
        
            typedef double ( ::cv::FeatureEvaluator::*calcOrd_function_type )( int ) const;
            typedef double ( FeatureEvaluator_wrapper::*default_calcOrd_function_type )( int ) const;
            
            FeatureEvaluator_exposer.def( 
                "calcOrd"
                , calcOrd_function_type(&::cv::FeatureEvaluator::calcOrd)
                , default_calcOrd_function_type(&FeatureEvaluator_wrapper::default_calcOrd)
                , ( bp::arg("featureIdx") ) );
        
        }
        { //::cv::FeatureEvaluator::clone
        
            typedef ::cv::Ptr< cv::FeatureEvaluator > ( ::cv::FeatureEvaluator::*clone_function_type )(  ) const;
            typedef ::cv::Ptr< cv::FeatureEvaluator > ( FeatureEvaluator_wrapper::*default_clone_function_type )(  ) const;
            
            FeatureEvaluator_exposer.def( 
                "clone"
                , clone_function_type(&::cv::FeatureEvaluator::clone)
                , default_clone_function_type(&FeatureEvaluator_wrapper::default_clone) );
        
        }
        { //::cv::FeatureEvaluator::create
        
            typedef ::cv::Ptr< cv::FeatureEvaluator > ( *create_function_type )( int );
            
            FeatureEvaluator_exposer.def( 
                "create"
                , create_function_type( &::cv::FeatureEvaluator::create )
                , ( bp::arg("type") ) );
        
        }
        { //::cv::FeatureEvaluator::getFeatureType
        
            typedef int ( ::cv::FeatureEvaluator::*getFeatureType_function_type )(  ) const;
            typedef int ( FeatureEvaluator_wrapper::*default_getFeatureType_function_type )(  ) const;
            
            FeatureEvaluator_exposer.def( 
                "getFeatureType"
                , getFeatureType_function_type(&::cv::FeatureEvaluator::getFeatureType)
                , default_getFeatureType_function_type(&FeatureEvaluator_wrapper::default_getFeatureType) );
        
        }
        { //::cv::FeatureEvaluator::read
        
            typedef bool ( ::cv::FeatureEvaluator::*read_function_type )( ::cv::FileNode const & ) ;
            typedef bool ( FeatureEvaluator_wrapper::*default_read_function_type )( ::cv::FileNode const & ) ;
            
            FeatureEvaluator_exposer.def( 
                "read"
                , read_function_type(&::cv::FeatureEvaluator::read)
                , default_read_function_type(&FeatureEvaluator_wrapper::default_read)
                , ( bp::arg("node") ) );
        
        }
        { //::cv::FeatureEvaluator::setImage
        
            typedef bool ( ::cv::FeatureEvaluator::*setImage_function_type )( ::cv::Mat const &,::cv::Size ) ;
            typedef bool ( FeatureEvaluator_wrapper::*default_setImage_function_type )( ::cv::Mat const &,::cv::Size ) ;
            
            FeatureEvaluator_exposer.def( 
                "setImage"
                , setImage_function_type(&::cv::FeatureEvaluator::setImage)
                , default_setImage_function_type(&FeatureEvaluator_wrapper::default_setImage)
                , ( bp::arg("arg0"), bp::arg("origWinSize") ) );
        
        }
        { //::cv::FeatureEvaluator::setWindow
        
            typedef bool ( ::cv::FeatureEvaluator::*setWindow_function_type )( ::cv::Point ) ;
            typedef bool ( FeatureEvaluator_wrapper::*default_setWindow_function_type )( ::cv::Point ) ;
            
            FeatureEvaluator_exposer.def( 
                "setWindow"
                , setWindow_function_type(&::cv::FeatureEvaluator::setWindow)
                , default_setWindow_function_type(&FeatureEvaluator_wrapper::default_setWindow)
                , ( bp::arg("p") ) );
        
        }
        FeatureEvaluator_exposer.staticmethod( "create" );
    }

}
