Python output_type1 예제들

예제 #1

파일: ml_gen.py 프로젝트: BackupGGCode/pyopencv

sb.finalize_class(z)

# CvBoostTree
z = sb.mb.class_('CvBoostTree')
sb.init_class(z)
sb.finalize_class(z)

# CvBoost
z = sb.mb.class_('CvBoost')
sb.init_class(z)
for t in ('train', 'predict'):
    for t2 in z.mem_funs(t):
        t2._transformer_kwds['alias'] = t
        if t=='predict': # workaround to fix a bug with CV_WHOLE_SEQ
            t2.arguments[3].default_value = "cv::Range( 0, 0x3fffffff )"
            t2._transformer_creators.append(FT.output_type1('weak_responses'))
sb.finalize_class(z)

# CvANN_MLP_TrainParams
z = sb.mb.class_('CvANN_MLP_TrainParams')
sb.init_class(z)
sb.finalize_class(z)

# CvANN_MLP
z = sb.mb.class_('CvANN_MLP')
sb.init_class(z)
for t in ('create', 'train', 'predict'):
    for t2 in z.mem_funs(t):
        t2._transformer_kwds['alias'] = t

# workaround for the long constructor (their code not yet implemented)

예제 #2

    
    std::vector<int> result(inst.dims());
    for(i = 0; i < inst.dims(); ++i) result[i] = sz[i];
    return bp::object(result);
}
''')
z.add_registration_code(
    'def("size", &::SparseMat_size, (bp::arg("i")=bp::object(-1)))')
z1 = z.mem_fun(
    lambda x: x.name == "begin" and "const" not in x.partial_decl_string)
z1.include()
z1.rename("__iter__")
z.mem_fun(lambda x: x.name == 'hash' and 'int const *' in x.arguments[0].type.decl_string) \
    ._transformer_creators.append(FT.input_array1d('idx'))
for z2 in z.mem_funs('erase'):
    z2._transformer_creators.append(FT.output_type1('hashval'))
    if z2.arguments[0].name == 'idx':
        z2._transformer_creators.append(FT.input_array1d('idx'))
# Hdr
z1 = z.class_('Hdr')
sb.init_class(z1)
z1.constructor(lambda x: len(x.arguments) > 1).exclude()
z1.add_declaration_code('''
static boost::shared_ptr<cv::SparseMat::Hdr> SparseMat_Hdr__init1__(std::vector<int> const &_sizes, int _type)
{
    return boost::shared_ptr<cv::SparseMat::Hdr>(new cv::SparseMat::Hdr(_sizes.size(), &_sizes[0], _type));
}

''')
z1.add_registration_code(
    'def("__init__", bp::make_constructor(&SparseMat_Hdr__init1__, bp::default_call_policies(), ( bp::arg("_sizes"), bp::arg("_type") )))'

예제 #3

파일: cv_h_gen.py 프로젝트: BackupGGCode/pyopencv

''')

# functions
for z in (
    'cvSmooth', 'cvPyrMeanShiftFiltering',         
    'cvLogPolar', 'cvLinearPolar',
    'cvSampleLine', 'cvGetQuadrangleSubPix',
    ):
    sb.mb.free_fun(z).include()
    

# cvPyrSegmentation
FT.expose_func(sb.mb.free_fun('cvPyrSegmentation'), ward_indices=(3,), transformer_creators=[
    FT.output_type1('comp', ignore_call_policies=False)])

# cvCalcEMD2
FT.expose_func(sb.mb.free_fun('cvCalcEMD2'), return_pointee=False, transformer_creators=[
    FT.distance_function('distance_func', 'userdata')])
sb.add_doc('calcEMD2', 
    "'distance_func' is a Python function declared as follows:",
    "    def distance_func((int)a, (int)b, (object)userdata) -> (float)x",
    "where",
    "    'a' : the address of a C array of C floats representing the first vector",
    "    'b' : the address of a C array of C floats representing the second vector",
    "    'userdata' : the 'userdata' parameter of cvCalcEMD2()",
    "    'x' : the resultant distance")

# Contours Retrieving
sb.cc.write('''

예제 #4

# PlanarObjectDetector
z = sb.mb.class_('PlanarObjectDetector')
sb.init_class(z)
z2 = [x for x in z.constructors()] + [x for x in z.mem_funs()]
for t in z2:
    for arg in t.arguments:
        if arg.default_value is not None and ('DEFAULT' in arg.default_value
                                              or 'PATCH' in arg.default_value):
            arg.default_value = 'cv::FernClassifier::' + arg.default_value
for t in ('getModelROI', 'getClassifier', 'getDetector'):
    z.mem_fun(t).exclude()  # definition not yet available
for z2 in z.operators('()'):
    z2._transformer_creators.append(FT.arg_output('corners'))
    if len(z2.arguments) == 5:
        z2._transformer_creators.append(FT.output_type1('pairs'))
sb.finalize_class(z)

# LevMarqSparse
z = sb.mb.class_('LevMarqSparse')
sb.init_class(z)
z.constructor(lambda x: len(x.arguments) > 1).exclude()
z.mem_fun('run').exclude()
z.add_wrapper_code('''
    bp::object fjac, func, data;
    
    // real callback for estimation of Jacobian matrices
    static void real_fjac(int i, int j, cv::Mat& point_params,
                           cv::Mat& cam_params, cv::Mat& A, cv::Mat& B, void* data)
    {
        LevMarqSparse_wrapper *self = (LevMarqSparse_wrapper *)data;

예제 #5

파일: cvaux_gen.py 프로젝트: BackupGGCode/pyopencv

sb.expose_class_vector('cv::FernClassifier::Feature', 'vector_FernClassifier_Feature')

# PlanarObjectDetector
z = sb.mb.class_('PlanarObjectDetector')
sb.init_class(z)
z2 = [x for x in z.constructors()]+[x for x in z.mem_funs()]
for t in z2:
    for arg in t.arguments:
        if arg.default_value is not None and ('DEFAULT' in arg.default_value or 'PATCH' in arg.default_value):
            arg.default_value = 'cv::FernClassifier::'+arg.default_value
for t in ('getModelROI', 'getClassifier', 'getDetector'):
    z.mem_fun(t).exclude() # definition not yet available
for z2 in z.operators('()'):
    z2._transformer_creators.append(FT.arg_output('corners'))
    if len(z2.arguments)==5:
        z2._transformer_creators.append(FT.output_type1('pairs'))
sb.finalize_class(z)

# LevMarqSparse
z = sb.mb.class_('LevMarqSparse')
sb.init_class(z)
z.constructor(lambda x: len(x.arguments) > 1).exclude()
z.mem_fun('run').exclude()
z.add_wrapper_code('''
    bp::object fjac, func, data;
    
    // real callback for estimation of Jacobian matrices
    static void real_fjac(int i, int j, cv::Mat& point_params,
                           cv::Mat& cam_params, cv::Mat& A, cv::Mat& B, void* data)
    {
        LevMarqSparse_wrapper *self = (LevMarqSparse_wrapper *)data;

예제 #6

파일: cxcore_hpp_gen.py 프로젝트: BackupGGCode/pyopencv

    const int *sz = inst.size();
    if(!sz) return bp::object();
    
    std::vector<int> result(inst.dims());
    for(i = 0; i < inst.dims(); ++i) result[i] = sz[i];
    return bp::object(result);
}
''')
z.add_registration_code('def("size", &::SparseMat_size, (bp::arg("i")=bp::object(-1)))')
z1 = z.mem_fun(lambda x: x.name=="begin" and "const" not in x.partial_decl_string)
z1.include()
z1.rename("__iter__")
z.mem_fun(lambda x: x.name == 'hash' and 'int const *' in x.arguments[0].type.decl_string) \
    ._transformer_creators.append(FT.input_array1d('idx'))
for z2 in z.mem_funs('erase'):
    z2._transformer_creators.append(FT.output_type1('hashval'))
    if z2.arguments[0].name == 'idx':
        z2._transformer_creators.append(FT.input_array1d('idx'))
# Hdr
z1 = z.class_('Hdr')
sb.init_class(z1)
z1.constructor(lambda x: len(x.arguments) > 1).exclude()
z1.add_declaration_code('''
static boost::shared_ptr<cv::SparseMat::Hdr> SparseMat_Hdr__init1__(std::vector<int> const &_sizes, int _type)
{
    return boost::shared_ptr<cv::SparseMat::Hdr>(new cv::SparseMat::Hdr(_sizes.size(), &_sizes[0], _type));
}

''')
z1.add_registration_code('def("__init__", bp::make_constructor(&SparseMat_Hdr__init1__, bp::default_call_policies(), ( bp::arg("_sizes"), bp::arg("_type") )))')    
sb.finalize_class(z1)

예제 #7

파일: cv_hpp_gen.py 프로젝트: uniquerobot/pyopencv

# 'HoughCircles', 'HoughLines', 'HoughLinesP'
FT.expose_func(sb.mb.free_fun('HoughCircles'),
               return_pointee=False,
               transformer_creators=[FT.arg_output('circles')])
FT.expose_func(sb.mb.free_fun('HoughLines'),
               return_pointee=False,
               transformer_creators=[FT.arg_output('lines')])
FT.expose_func(sb.mb.free_fun('HoughLinesP'),
               return_pointee=False,
               transformer_creators=[FT.arg_output('lines')])

# getOptimalNewCameraMatrix
FT.expose_func(sb.mb.free_fun('getOptimalNewCameraMatrix'),
               return_pointee=False,
               transformer_creators=[FT.output_type1('validPixROI')])

# calcHist
for z in sb.mb.free_funs('calcHist'):
    FT.expose_func(z,
                   return_pointee=False,
                   transformer_creators=[
                       FT.input_array1d('images', 'nimages'),
                       FT.input_array1d('channels'),
                       FT.input_array1d('histSize', 'dims'),
                       FT.input_array2d('ranges')
                   ])
    z._transformer_kwds['alias'] = 'calcHist'

# calcBackProject
for z in sb.mb.free_funs('calcBackProject'):

예제 #8

파일: cv_hpp_gen.py 프로젝트: BackupGGCode/pyopencv

        
# goodFeaturesToTrack
FT.expose_func(sb.mb.free_fun('goodFeaturesToTrack'), return_pointee=False, 
    transformer_creators=[FT.arg_output('corners')])

# 'HoughCircles', 'HoughLines', 'HoughLinesP'
FT.expose_func(sb.mb.free_fun('HoughCircles'), return_pointee=False, 
    transformer_creators=[FT.arg_output('circles')])
FT.expose_func(sb.mb.free_fun('HoughLines'), return_pointee=False, 
    transformer_creators=[FT.arg_output('lines')])
FT.expose_func(sb.mb.free_fun('HoughLinesP'), return_pointee=False, 
    transformer_creators=[FT.arg_output('lines')])

# getOptimalNewCameraMatrix
FT.expose_func(sb.mb.free_fun('getOptimalNewCameraMatrix'), return_pointee=False, 
    transformer_creators=[FT.output_type1('validPixROI')])

# calcHist
for z in sb.mb.free_funs('calcHist'):
    FT.expose_func(z, return_pointee=False, transformer_creators=[
        FT.input_array1d('images', 'nimages'), FT.input_array1d('channels'),
        FT.input_array1d('histSize', 'dims'), FT.input_array2d('ranges')])
    z._transformer_kwds['alias'] = 'calcHist'
        
        
# calcBackProject
for z in sb.mb.free_funs('calcBackProject'):
    FT.expose_func(z, return_pointee=False, transformer_creators=[
        FT.input_array1d('images', 'nimages'), FT.input_array1d('channels'),
        FT.input_array2d('ranges')])
    z._transformer_kwds['alias'] = 'calcBackProject'

예제 #9

sb.finalize_class(z)

# CvBoostTree
z = sb.mb.class_('CvBoostTree')
sb.init_class(z)
sb.finalize_class(z)

# CvBoost
z = sb.mb.class_('CvBoost')
sb.init_class(z)
for t in ('train', 'predict'):
    for t2 in z.mem_funs(t):
        t2._transformer_kwds['alias'] = t
        if t == 'predict':  # workaround to fix a bug with CV_WHOLE_SEQ
            t2.arguments[3].default_value = "cv::Range( 0, 0x3fffffff )"
            t2._transformer_creators.append(FT.output_type1('weak_responses'))
sb.finalize_class(z)

# CvANN_MLP_TrainParams
z = sb.mb.class_('CvANN_MLP_TrainParams')
sb.init_class(z)
sb.finalize_class(z)

# CvANN_MLP
z = sb.mb.class_('CvANN_MLP')
sb.init_class(z)
for t in ('create', 'train', 'predict'):
    for t2 in z.mem_funs(t):
        t2._transformer_kwds['alias'] = t

# workaround for the long constructor (their code not yet implemented)

예제 #10

# functions
for z in (
        'cvSmooth',
        'cvPyrMeanShiftFiltering',
        'cvLogPolar',
        'cvLinearPolar',
        'cvSampleLine',
        'cvGetQuadrangleSubPix',
):
    sb.mb.free_fun(z).include()

# cvPyrSegmentation
FT.expose_func(
    sb.mb.free_fun('cvPyrSegmentation'),
    ward_indices=(3, ),
    transformer_creators=[FT.output_type1('comp', ignore_call_policies=False)])

# cvCalcEMD2
FT.expose_func(
    sb.mb.free_fun('cvCalcEMD2'),
    return_pointee=False,
    transformer_creators=[FT.distance_function('distance_func', 'userdata')])
sb.add_doc(
    'calcEMD2', "'distance_func' is a Python function declared as follows:",
    "    def distance_func((int)a, (int)b, (object)userdata) -> (float)x",
    "where",
    "    'a' : the address of a C array of C floats representing the first vector",
    "    'b' : the address of a C array of C floats representing the second vector",
    "    'userdata' : the 'userdata' parameter of cvCalcEMD2()",
    "    'x' : the resultant distance")