195 lines
8.5 KiB
Python
195 lines
8.5 KiB
Python
|
#!/usr/bin/env python
|
||
|
|
import sys, re, os, time
|
||
|
|
from string import Template
|
||
|
|
from parse_tree import ParseTree, todict, constants
|
||
|
|
from filters import *
|
||
|
|
|
||
|
|
updated_files = []
|
||
|
|
|
||
|
|
def update_file(fname, content):
|
||
|
|
if fname in updated_files:
|
||
|
|
print('ERROR(gen_matlab.py): attemption to write file multiple times: {}'.format(fname))
|
||
|
|
return
|
||
|
|
updated_files.append(fname)
|
||
|
|
if os.path.exists(fname):
|
||
|
|
with open(fname, 'rb') as f:
|
||
|
|
old_content = f.read()
|
||
|
|
if old_content == content:
|
||
|
|
#print('Up-to-date: {}'.format(fname))
|
||
|
|
return
|
||
|
|
print('Updating: {}'.format(fname))
|
||
|
|
else:
|
||
|
|
print('Writing: {}'.format(fname))
|
||
|
|
with open(fname, 'wb') as f:
|
||
|
|
f.write(content)
|
||
|
|
|
||
|
|
|
||
|
|
class MatlabWrapperGenerator(object):
|
||
|
|
"""
|
||
|
|
MatlabWrapperGenerator is a class for generating Matlab mex sources from
|
||
|
|
a set of C++ headers. MatlabWrapperGenerator objects can be default
|
||
|
|
constructed. Given an instance, the gen() method performs the translation.
|
||
|
|
"""
|
||
|
|
|
||
|
|
def gen(self, module_roots, modules, extras, output_dir):
|
||
|
|
"""
|
||
|
|
Generate a set of Matlab mex source files by parsing exported symbols
|
||
|
|
in a set of C++ headers. The headers can be input in one (or both) of
|
||
|
|
two methods:
|
||
|
|
1. specify module_root and modules
|
||
|
|
Given a path to the OpenCV module root and a list of module names,
|
||
|
|
the headers to parse are implicitly constructed.
|
||
|
|
2. specifiy header locations explicitly in extras
|
||
|
|
Each element in the list of extras must be of the form:
|
||
|
|
'namespace=/full/path/to/extra/header.hpp' where 'namespace' is
|
||
|
|
the namespace in which the definitions should be added.
|
||
|
|
The output_dir specifies the directory to write the generated sources
|
||
|
|
to.
|
||
|
|
"""
|
||
|
|
# dynamically import the parsers
|
||
|
|
from jinja2 import Environment, FileSystemLoader
|
||
|
|
import hdr_parser
|
||
|
|
|
||
|
|
# parse each of the files and store in a dictionary
|
||
|
|
# as a separate "namespace"
|
||
|
|
parser = hdr_parser.CppHeaderParser()
|
||
|
|
|
||
|
|
ns = dict((key, []) for key in modules)
|
||
|
|
path_template = Template('${module}/include/opencv2/${module}.hpp')
|
||
|
|
|
||
|
|
for module in modules:
|
||
|
|
for module_root in module_roots:
|
||
|
|
# construct a header path from the module root and a path template
|
||
|
|
header = os.path.join(module_root, path_template.substitute(module=module))
|
||
|
|
if os.path.isfile(header):
|
||
|
|
break
|
||
|
|
else:
|
||
|
|
raise Exception('no header found for module %s!' % module)
|
||
|
|
|
||
|
|
# parse the definitions
|
||
|
|
ns[module] = parser.parse(header)
|
||
|
|
|
||
|
|
for extra in extras:
|
||
|
|
module = extra.split("=")[0]
|
||
|
|
header = extra.split("=")[1]
|
||
|
|
ns[module] = ns[module] + parser.parse(header) if module in ns else parser.parse(header)
|
||
|
|
|
||
|
|
# cleanify the parser output
|
||
|
|
parse_tree = ParseTree()
|
||
|
|
parse_tree.build(ns)
|
||
|
|
|
||
|
|
# setup the template engine
|
||
|
|
template_dir = os.path.join(os.path.dirname(__file__), 'templates')
|
||
|
|
jtemplate = Environment(loader=FileSystemLoader(template_dir), trim_blocks=True, lstrip_blocks=True)
|
||
|
|
|
||
|
|
# add the custom filters
|
||
|
|
jtemplate.filters['formatMatlabConstant'] = formatMatlabConstant
|
||
|
|
jtemplate.filters['convertibleToInt'] = convertibleToInt
|
||
|
|
jtemplate.filters['toUpperCamelCase'] = toUpperCamelCase
|
||
|
|
jtemplate.filters['toLowerCamelCase'] = toLowerCamelCase
|
||
|
|
jtemplate.filters['toUnderCase'] = toUnderCase
|
||
|
|
jtemplate.filters['matlabURL'] = matlabURL
|
||
|
|
jtemplate.filters['stripTags'] = stripTags
|
||
|
|
jtemplate.filters['filename'] = filename
|
||
|
|
jtemplate.filters['comment'] = comment
|
||
|
|
jtemplate.filters['inputs'] = inputs
|
||
|
|
jtemplate.filters['ninputs'] = ninputs
|
||
|
|
jtemplate.filters['outputs'] = outputs
|
||
|
|
jtemplate.filters['noutputs'] = noutputs
|
||
|
|
jtemplate.filters['qualify'] = qualify
|
||
|
|
jtemplate.filters['slugify'] = slugify
|
||
|
|
jtemplate.filters['only'] = only
|
||
|
|
jtemplate.filters['void'] = void
|
||
|
|
jtemplate.filters['not'] = flip
|
||
|
|
|
||
|
|
# load the templates
|
||
|
|
tfunction = jtemplate.get_template('template_function_base.cpp')
|
||
|
|
tclassm = jtemplate.get_template('template_class_base.m')
|
||
|
|
tclassc = jtemplate.get_template('template_class_base.cpp')
|
||
|
|
tconst = jtemplate.get_template('template_map_base.m')
|
||
|
|
|
||
|
|
# create the build directory
|
||
|
|
output_source_dir = output_dir+'/src'
|
||
|
|
output_private_dir = output_source_dir+'/private'
|
||
|
|
output_class_dir = output_dir+'/+cv'
|
||
|
|
output_map_dir = output_dir+'/map'
|
||
|
|
if not os.path.isdir(output_source_dir):
|
||
|
|
os.makedirs(output_source_dir)
|
||
|
|
if not os.path.isdir(output_private_dir):
|
||
|
|
os.makedirs(output_private_dir)
|
||
|
|
if not os.path.isdir(output_class_dir):
|
||
|
|
os.makedirs(output_class_dir)
|
||
|
|
if not os.path.isdir(output_map_dir):
|
||
|
|
os.makedirs(output_map_dir)
|
||
|
|
|
||
|
|
# populate templates
|
||
|
|
for namespace in parse_tree.namespaces:
|
||
|
|
# functions
|
||
|
|
for method in namespace.methods:
|
||
|
|
populated = tfunction.render(fun=method, time=time, includes=namespace.name)
|
||
|
|
update_file(output_source_dir+'/'+method.name+'.cpp', populated.encode('utf-8'))
|
||
|
|
# classes
|
||
|
|
for clss in namespace.classes:
|
||
|
|
# cpp converter
|
||
|
|
populated = tclassc.render(clss=clss, time=time)
|
||
|
|
update_file(output_private_dir+'/'+clss.name+'Bridge.cpp', populated.encode('utf-8'))
|
||
|
|
# matlab classdef
|
||
|
|
populated = tclassm.render(clss=clss, time=time)
|
||
|
|
update_file(output_class_dir+'/'+clss.name+'.m', populated.encode('utf-8'))
|
||
|
|
|
||
|
|
# create a global constants lookup table
|
||
|
|
const = dict(constants(todict(parse_tree.namespaces)))
|
||
|
|
populated = tconst.render(constants=const, time=time)
|
||
|
|
update_file(output_dir+'/cv.m', populated.encode('utf-8'))
|
||
|
|
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
"""
|
||
|
|
Usage: python gen_matlab.py
|
||
|
|
--hdrparser /path/to/hdr_parser/dir
|
||
|
|
--moduleroot [ /path/to/opencv/modules /path/to/opencv_contrib/modules etc ]
|
||
|
|
--modules [core imgproc objdetect etc]
|
||
|
|
--extra namespace=/path/to/extra/header.hpp
|
||
|
|
--outdir /path/to/output/generated/srcs
|
||
|
|
|
||
|
|
gen_matlab.py is the main control script for generating matlab source
|
||
|
|
files from given set of headers. Internally, gen_matlab:
|
||
|
|
1. constructs the headers to parse from the module root and list of modules
|
||
|
|
2. parses the headers using CppHeaderParser
|
||
|
|
3. refactors the definitions using ParseTree
|
||
|
|
4. populates the templates for classes, function, enums from the
|
||
|
|
definitions
|
||
|
|
|
||
|
|
gen_matlab.py requires the following inputs:
|
||
|
|
--hdrparser the path to the header parser directory
|
||
|
|
(opencv/modules/python/src2)
|
||
|
|
--moduleroot (optional) paths to the opencv directories containing the modules
|
||
|
|
--modules (optional - required if --moduleroot specified) the modules
|
||
|
|
to produce bindings for. The path to the include directories
|
||
|
|
as well as the namespaces are constructed from the modules
|
||
|
|
and the moduleroot
|
||
|
|
--extra extra headers explicitly defined to parse. This must be in
|
||
|
|
the format "namepsace=/path/to/extra/header.hpp". For example,
|
||
|
|
the core module requires the extra header:
|
||
|
|
"core=/opencv/modules/core/include/opencv2/core/core/base.hpp"
|
||
|
|
--outdir the output directory to put the generated matlab sources. In
|
||
|
|
the OpenCV build this is "${CMAKE_CURRENT_BUILD_DIR}/src"
|
||
|
|
"""
|
||
|
|
|
||
|
|
# parse the input options
|
||
|
|
from argparse import ArgumentParser
|
||
|
|
parser = ArgumentParser()
|
||
|
|
parser.add_argument('--hdrparser')
|
||
|
|
parser.add_argument('--moduleroot', nargs='*', default=[], required=False)
|
||
|
|
parser.add_argument('--modules', nargs='*', default=[], required=False)
|
||
|
|
parser.add_argument('--extra', nargs='*', default=[], required=False)
|
||
|
|
parser.add_argument('--outdir')
|
||
|
|
args = parser.parse_args()
|
||
|
|
|
||
|
|
# add the hdr_parser module to the path
|
||
|
|
sys.path.append(args.hdrparser)
|
||
|
|
|
||
|
|
# create the generator
|
||
|
|
mwg = MatlabWrapperGenerator()
|
||
|
|
mwg.gen(args.moduleroot, args.modules, args.extra, args.outdir)
|