rbind 0.0.27 → 0.0.33

data/lib/rbind/generator_extern.rb

@@ -32,8 +32,10 @@ module Rbind
 
             #write all types so they get parsed first
             @root.each_type do |t|
-                if t.is_a? RClass
+                if t.is_a?(RClass) 
                     file_extern.write "class #{GeneratorExtern.normalize_type_name(t.full_name)}\n"
+                elsif t.is_a?(REnum)
+                    file_extern.write "enum #{GeneratorExtern.normalize_type_name(t.full_name)}\n"
                 end
             end
 

data/lib/rbind/generator_ruby.rb

@@ -15,7 +15,7 @@ module Rbind
         end
         self.ruby_default_value_map ||= {"true" => "true","TRUE" => "true", "false" => "false","FALSE" => "false"}
         self.ffi_type_map ||= {"char *" => "string","unsigned char" => "uchar" ,"const char *" => "string","uint8_t" => "uint8",
-                               "uint32_t" => "uint32","uint64_t" => "uint64","int8_t" => "int8","int32_t" => "int32","int64_t" => "int64" }
+                               "uint16_t" => "uint16","int16_t" => "int16", "uint32_t" => "uint32","uint64_t" => "uint64","int8_t" => "int8","int32_t" => "int32","int64_t" => "int64" }
 
 
         def self.keyword?(name)
@@ -62,8 +62,10 @@ module Rbind
             val = if parameter.type.basic_type? || parameter.type.ptr?
                       if ruby_default_value_map.has_key?(parameter.default_value)
                           ruby_default_value_map[parameter.default_value]
+                      elsif parameter.type.is_a? REnum
+                          ":#{parameter.default_value.split("::").last}"
                       elsif parameter.type.name == "float"
-                          parameter.default_value.gsub("f","").gsub(/\.$/,".0").gsub(/^\./,"0.")
+                          parameter.default_value.gsub("f","").gsub("F","").gsub(/\.$/,".0").gsub(/^\./,"0.")
                       elsif parameter.type.name == "double"
                           parameter.default_value.gsub(/\.$/,".0").gsub(/^\./,"0.")
                       elsif parameter.type.ptr? &&(parameter.default_value == "0" || parameter.default_value = "NULL")
@@ -131,7 +133,12 @@ module Rbind
             # map template classes
             # std::vector<std::string> -> Std::Vector::Std_String
             if name =~ /([\w:]*)<(.*)>$/
-                return "#{normalize_type_name($1,true)}::#{normalize_type_name($2,true).gsub("::","_")}"
+                name = $1
+                names = $2.split(",")
+                names.map! do |val|
+                    normalize_type_name(val,true).gsub("::","_")
+                end
+                return "#{normalize_type_name(name,true)}::#{names.join("_")}"
             else
                 name
             end
@@ -246,6 +253,21 @@ module Rbind
             name
         end
 
+        def self.normalize_const_value(name)
+            name = name.to_s.gsub(" ","")
+            # Parse constant declaration with suffix like 1000000LL
+            if name =~ /^([0-9]+)[uUlL]{0,2}/
+                name = $1
+                return name
+            end
+            # upcase first letter 
+            name = name.gsub(/\w*/) do |n|
+                next unless n.size > 0
+                n[0].upcase+n[1,n.size-1]
+            end
+            name
+        end
+
         class HelperBase
             extend ::Rbind::Logger
 
@@ -332,11 +354,10 @@ module Rbind
                                                   op_return_type = klass if klass.kind_of?(REnum)
                                               end
                                           end
-
                                           if op_return_type.basic_type?
                                               if op_return_type.ptr?
                                                   ":pointer"
-                                              elsif op_return_type.kind_of?(REnum)
+					      elsif op.return_type.to_raw.kind_of?(REnum)
                                                   ":#{normalize_enum op_return_type.to_raw.csignature}"
                                               else
                                                   ":#{normalize_bt op_return_type.to_raw.csignature}"
@@ -344,7 +365,7 @@ module Rbind
                                           else
                                               if op_return_type.extern_package_name
                                                   normalize_t("::#{op_return_type.extern_package_name}::#{op_return_type.to_raw.full_name}")
-                                              elsif op_return_type.kind_of?(REnum)
+					      elsif op_return_type.to_raw.kind_of?(REnum)
                                                   ":#{normalize_enum op_return_type.to_raw.full_name}"
                                               else
                                                   normalize_t op_return_type.to_raw.full_name
@@ -361,7 +382,7 @@ module Rbind
                             if p_type.basic_type?
                                 if p_type.ptr? || p.type.ref?
                                     ":pointer"
-                                elsif p.type.kind_of?(REnum)
+				elsif p.type.to_raw.kind_of?(REnum)
                                     # Includes enums, which need to be defined accordingly
                                     # using ffi:
                                     # enum :normalized_name, [:first, 1,
@@ -375,7 +396,7 @@ module Rbind
                             else
                                 if p_type.extern_package_name
                                     normalize_t("::#{p_type.extern_package_name}::#{p_type.to_raw.full_name}")
-                                elsif p_type.kind_of?(REnum)
+				elsif p_type.to_raw.kind_of?(REnum)
                                     ":#{normalize_enum p_type.to_raw.full_name}"
                                 else
                                     normalize_t p_type.to_raw.full_name
@@ -383,6 +404,7 @@ module Rbind
                             end
                         end
                         fct_name = normalize_m op.cname
+                        str += "@blocking = true; "if op.blocking?
                         str += "attach_function :#{fct_name},:#{op.cname},[#{args.join(",")}],#{return_type}\n"
                         str
                     end
@@ -399,12 +421,13 @@ module Rbind
                         str += "\tenum :#{GeneratorRuby::normalize_enum_name(t.to_raw.csignature)}, ["
                         t.values.each do |name,value|
                             if value
-                                str += ":#{name},#{value}, "
+                                value = GeneratorRuby.normalize_const_value(value)
+                                str += ":#{name},#{GeneratorRuby.normalize_type_name(value)}, "
                             else
                                 str += ":#{name}, "
                             end
                         end
-                        str += "]\n\n"
+                        str += "]\n"
                     end
                 end
                 str
@@ -669,17 +692,21 @@ module Rbind
             end
 
             def add_consts(root=@root)
-                str = @root.consts.map do |c|
+                str = root.consts.map do |c|
                     next if c.extern? || c.ignore?
                     if not c.default_value
                         HelperBase.log.warn "#{c.name}: no default value"
                         next
                     else
-                    "    #{c.name} = #{GeneratorRuby::normalize_type_name(c.default_value)}\n"
+                        val = begin
+                                  eval(c.default_value)
+                              rescue
+                                  GeneratorRuby::normalize_const_value(c.default_value)
+                              end
+                    "    #{c.name} = #{val}\n"
                     end
                 end.join
                 return str unless @compact_namespace
-
                 root.each_type(false) do |t|
                     next if t.basic_type? && !t.is_a?(RNamespace)
                     str += add_consts(t) if name == GeneratorRuby.normalize_type_name(t.full_name)

data/lib/rbind/templates/c/type_conversion.cc

@@ -17,7 +17,7 @@ const <%= cname %>* toC(const <%= full_name %>* ptr, bool owner)
 }
 
 // converts const <%= cname %> to const <%= full_name %>
-const <%= full_name %>* fromC(const <%= cname %>* ptr)
+const <%= full_name %>* fromC(const <%= cname %>* ptr,bool parse_owner)
 {
     if(ptr == NULL)
         throw std::runtime_error("<%= full_name %>: Null Pointer!");
@@ -38,14 +38,20 @@ const <%= full_name %>* fromC(const <%= cname %>* ptr)
     // check size
     if(ptr->size && sizeof(<%= full_name %>) > ptr->size)
         throw std::runtime_error("wrong object size for <%= full_name %>.");
+    if(parse_owner)
+        throw std::runtime_error("cannot parse ownerhsip for const parameter for <%= full_name %>.");
     return static_cast<const <%= full_name %>*>(ptr->obj_ptr);
 }
 
 // converts <%= cname %>* to <%= full_name %>*
-<%= full_name %>* fromC(<%= cname %>* ptr)
+<%= full_name %>* fromC(<%= cname %>* ptr,bool parse_owner)
 {
     if(ptr == NULL)
         return NULL;
-    return const_cast<<%= full_name %>*>(fromC(static_cast<const <%= cname %>*>(ptr)));
+    if(parse_owner && !ptr->bowner)
+        throw std::runtime_error("Cannot parse ownership. The given object is already owned by someone else  <%= full_name %>.");
+    if(parse_owner)
+	ptr->bowner = false;
+    return const_cast<<%= full_name %>*>(fromC(static_cast<const <%= cname %>*>(ptr),false));
 }
 

data/lib/rbind/templates/c/type_conversion.hpp

@@ -1,6 +1,6 @@
 // convert functions for <%= full_name %>* to and from <%= cname %>*
 const <%= cname %>* toC(const <%= full_name %>* ptr, bool owner = true);
 <%= cname %>* toC(<%= full_name %>* ptr, bool owner = true);
-const <%= full_name %>* fromC(const <%= cname %>* ptr);
-<%= full_name %>* fromC(<%= cname %>* ptr);
+const <%= full_name %>* fromC(const <%= cname %>* ptr,bool parse_ownership=false);
+<%= full_name %>* fromC(<%= cname %>* ptr,bool parse_ownership=false);
 

data/lib/rbind/tools/hdr_parser.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 from __future__ import print_function
-import os, sys, re, string
+import os, sys, re, string, io
 
 # the list only for debugging. The real list, used in the real OpenCV build, is specified in CMakeLists.txt
 opencv_hdr_list = [
@@ -17,27 +17,33 @@ opencv_hdr_list = [
 "../../objdetect/include/opencv2/objdetect.hpp",
 "../../imgcodecs/include/opencv2/imgcodecs.hpp",
 "../../videoio/include/opencv2/videoio.hpp",
-"../../highgui/include/opencv2/highgui.hpp"
+"../../highgui/include/opencv2/highgui.hpp",
 ]
 
 """
-Each declaration is [funcname, return_value_type /* in C, not in Python */, <list_of_modifiers>, <list_of_arguments>],
+Each declaration is [funcname, return_value_type /* in C, not in Python */, <list_of_modifiers>, <list_of_arguments>, original_return_type, docstring],
 where each element of <list_of_arguments> is 4-element list itself:
 [argtype, argname, default_value /* or "" if none */, <list_of_modifiers>]
 where the list of modifiers is yet another nested list of strings
    (currently recognized are "/O" for output argument, "/S" for static (i.e. class) methods
    and "/A value" for the plain C arrays with counters)
+original_return_type is None if the original_return_type is the same as return_value_type
 """
 
 class CppHeaderParser(object):
 
-    def __init__(self):
+    def __init__(self, generate_umat_decls=False, generate_gpumat_decls=False):
+        self._generate_umat_decls = generate_umat_decls
+        self._generate_gpumat_decls = generate_gpumat_decls
+
         self.BLOCK_TYPE = 0
         self.BLOCK_NAME = 1
         self.PROCESS_FLAG = 2
         self.PUBLIC_SECTION = 3
         self.CLASS_DECL = 4
 
+        self.namespaces = set()
+
     def batch_replace(self, s, pairs):
         for before, after in pairs:
             s = s.replace(before, after)
@@ -100,6 +106,14 @@ class CppHeaderParser(object):
             modlist.append("/CA " + macro_arg)
             arg_str = arg_str[:npos] + arg_str[npos3+1:]
 
+        npos = arg_str.find("const")
+        if npos >= 0:
+            modlist.append("/C")
+
+        npos = arg_str.find("&")
+        if npos >= 0:
+            modlist.append("/Ref")
+
         arg_str = arg_str.strip()
         word_start = 0
         word_list = []
@@ -222,7 +236,7 @@ class CppHeaderParser(object):
             else:
                 prev_val_delta = 0
                 prev_val = val = pv[1].strip()
-            decl.append(["const " + self.get_dotted_name(pv[0].strip()), val, [], []])
+            decl.append(["const " + self.get_dotted_name(pv[0].strip()), val, [], [], None, ""])
         return decl
 
     def parse_class_decl(self, decl_str):
@@ -246,13 +260,13 @@ class CppHeaderParser(object):
             l = l[:npos] + l[npos3+1:]
 
         l = self.batch_replace(l, [("CV_EXPORTS_W", ""), ("CV_EXPORTS", ""), ("public virtual ", " "), ("public ", " "), ("::", ".")]).strip()
-        ll = re.split(r'\s*[,:]?\s*', l)
+        ll = re.split(r'\s+|\s*[,:]\s*', l)
         ll = [le for le in ll if le]
         classname = ll[1]
         bases = ll[2:]
         return classname, bases, modlist
 
-    def parse_func_decl_no_wrap(self, decl_str, static_method = False):
+    def parse_func_decl_no_wrap(self, decl_str, static_method=False, docstring=""):
         decl_str = (decl_str or "").strip()
         virtual_method = False
         explicit_method = False
@@ -295,7 +309,7 @@ class CppHeaderParser(object):
             apos = fdecl.find("(", apos+1)
 
         fname = "cv." + fname.replace("::", ".")
-        decl = [fname, rettype, [], []]
+        decl = [fname, rettype, [], [], None, docstring]
 
         # inline constructor implementation
         implmatch = re.match(r"(\(.*?\))\s*:\s*(\w+\(.*?\),?\s*)+", fdecl[apos:])
@@ -362,11 +376,9 @@ class CppHeaderParser(object):
             decl[2].append("/A")
         if bool(re.match(r".*\)\s*const(\s*=\s*0)?", decl_str)):
             decl[2].append("/C")
-        if "virtual" in decl_str:
-            print(decl_str)
         return decl
 
-    def parse_func_decl(self, decl_str):
+    def parse_func_decl(self, decl_str, mat="Mat", docstring=""):
         """
         Parses the function or method declaration in the form:
         [([CV_EXPORTS] <rettype>) | CVAPI(rettype)]
@@ -375,12 +387,11 @@ class CppHeaderParser(object):
             [const] {; | <function_body>}
 
         Returns the function declaration entry:
-        [<func name>, <return value C-type>, <list of modifiers>, <list of arguments>] (see above)
+        [<func name>, <return value C-type>, <list of modifiers>, <list of arguments>, <original return type>, <docstring>] (see above)
         """
 
         if self.wrap_mode:
-            if not (("CV_EXPORTS_AS" in decl_str) or ("CV_EXPORTS_W" in decl_str) or \
-                ("CV_WRAP" in decl_str) or ("CV_WRAP_AS" in decl_str)):
+            if not (("CV_EXPORTS_AS" in decl_str) or ("CV_EXPORTS_W" in decl_str) or ("CV_WRAP" in decl_str)):
                 return []
 
         # ignore old API in the documentation check (for now)
@@ -400,12 +411,37 @@ class CppHeaderParser(object):
             arg, npos3 = self.get_macro_arg(decl_str, npos)
             func_modlist.append("="+arg)
             decl_str = decl_str[:npos] + decl_str[npos3+1:]
+        npos = decl_str.find("CV_WRAP_PHANTOM")
+        if npos >= 0:
+            decl_str, _ = self.get_macro_arg(decl_str, npos)
+            func_modlist.append("/phantom")
+        npos = decl_str.find("CV_WRAP_MAPPABLE")
+        if npos >= 0:
+            mappable, npos3 = self.get_macro_arg(decl_str, npos)
+            func_modlist.append("/mappable="+mappable)
+            classname = top[1]
+            return ['.'.join([classname, classname]), None, func_modlist, [], None, None]
+
+        virtual_method = False
+        pure_virtual_method = False
+        const_method = False
 
         # filter off some common prefixes, which are meaningless for Python wrappers.
         # note that we do not strip "static" prefix, which does matter;
         # it means class methods, not instance methods
-        decl_str = self.batch_replace(decl_str, [("virtual", ""), ("static inline", ""), ("inline", ""),\
-            ("CV_EXPORTS_W", ""), ("CV_EXPORTS", ""), ("CV_CDECL", ""), ("CV_WRAP ", " "), ("CV_INLINE", "")]).strip()
+        decl_str = self.batch_replace(decl_str, [("static inline", ""), ("inline", ""),\
+            ("CV_EXPORTS_W", ""), ("CV_EXPORTS", ""), ("CV_CDECL", ""), ("CV_WRAP ", " "), ("CV_INLINE", ""),
+            ("CV_DEPRECATED", ""), ("CV_DEPRECATED_EXTERNAL", "")]).strip()
+
+
+        if decl_str.strip().startswith('virtual'):
+            virtual_method = True
+
+        decl_str = decl_str.replace('virtual' , '')
+
+        end_tokens = decl_str[decl_str.rfind(')'):].split()
+        const_method = 'const' in end_tokens
+        pure_virtual_method = '=' in end_tokens and '0' in end_tokens
 
         static_method = False
         context = top[0]
@@ -443,6 +479,12 @@ class CppHeaderParser(object):
 
         rettype, funcname, modlist, argno = self.parse_arg(decl_start, -1)
 
+        # determine original return type, hack for return types with underscore
+        original_type = None
+        i = decl_start.rfind(funcname)
+        if i > 0:
+            original_type = decl_start[:i].replace("&", "").replace("const", "").strip()
+
         if argno >= 0:
             classname = top[1]
             if rettype == classname or rettype == "~" + classname:
@@ -474,7 +516,7 @@ class CppHeaderParser(object):
         funcname = self.get_dotted_name(funcname)
 
         if not self.wrap_mode:
-            decl = self.parse_func_decl_no_wrap(decl_str, static_method)
+            decl = self.parse_func_decl_no_wrap(decl_str, static_method, docstring)
             decl[0] = funcname
             return decl
 
@@ -492,8 +534,6 @@ class CppHeaderParser(object):
             t, npos = self.find_next_token(decl_str, ["(", ")", ",", "<", ">"], npos)
             if not t:
                 print("Error: no closing ')' at %d" % (self.lineno,))
-                print(decl_str)
-                print(decl_str[arg_start:])
                 sys.exit(-1)
             if t == "<":
                 angle_balance += 1
@@ -529,41 +569,46 @@ class CppHeaderParser(object):
                         a = a[:eqpos].strip()
                     arg_type, arg_name, modlist, argno = self.parse_arg(a, argno)
                     if self.wrap_mode:
+                        # TODO: Vectors should contain UMat, but this is not very easy to support and not very needed
+                        vector_mat = "vector_{}".format("Mat")
+                        vector_mat_template = "vector<{}>".format("Mat")
+
                         if arg_type == "InputArray":
-                            arg_type = "Mat"
+                            arg_type = mat
                         elif arg_type == "InputOutputArray":
-                            arg_type = "Mat"
+                            arg_type = mat
                             modlist.append("/IO")
                         elif arg_type == "OutputArray":
-                            arg_type = "Mat"
+                            arg_type = mat
                             modlist.append("/O")
                         elif arg_type == "InputArrayOfArrays":
-                            arg_type = "vector_Mat"
+                            arg_type = vector_mat
                         elif arg_type == "InputOutputArrayOfArrays":
-                            arg_type = "vector_Mat"
+                            arg_type = vector_mat
                             modlist.append("/IO")
                         elif arg_type == "OutputArrayOfArrays":
-                            arg_type = "vector_Mat"
+                            arg_type = vector_mat
                             modlist.append("/O")
-                        defval = self.batch_replace(defval, [("InputArrayOfArrays", "vector<Mat>"),
-                                                             ("InputOutputArrayOfArrays", "vector<Mat>"),
-                                                             ("OutputArrayOfArrays", "vector<Mat>"),
-                                                             ("InputArray", "Mat"),
-                                                             ("InputOutputArray", "Mat"),
-                                                             ("OutputArray", "Mat"),
+                        defval = self.batch_replace(defval, [("InputArrayOfArrays", vector_mat_template),
+                                                             ("InputOutputArrayOfArrays", vector_mat_template),
+                                                             ("OutputArrayOfArrays", vector_mat_template),
+                                                             ("InputArray", mat),
+                                                             ("InputOutputArray", mat),
+                                                             ("OutputArray", mat),
                                                              ("noArray", arg_type)]).strip()
                     args.append([arg_type, arg_name, defval, modlist])
                 npos = arg_start-1
 
-        npos = decl_str.replace(" ", "").find("=0", npos)
-        if npos >= 0:
-            # skip pure virtual functions
-            return []
-
         if static_method:
             func_modlist.append("/S")
+        if const_method:
+            func_modlist.append("/C")
+        if virtual_method:
+            func_modlist.append("/V")
+        if pure_virtual_method:
+            func_modlist.append("/PV")
 
-        return [funcname, rettype, func_modlist, args]
+        return [funcname, rettype, func_modlist, args, original_type, docstring]
 
     def get_dotted_name(self, name):
         """
@@ -588,8 +633,10 @@ class CppHeaderParser(object):
             block_type, block_name = b[self.BLOCK_TYPE], b[self.BLOCK_NAME]
             if block_type in ["file", "enum"]:
                 continue
-            if block_type not in ["struct", "class", "namespace"]:
-                print("Error at %d: there are non-valid entries in the current block stack " % (self.lineno, self.block_stack))
+            if block_type in ["enum struct", "enum class"] and block_name == name:
+                continue
+            if block_type not in ["struct", "class", "namespace", "enum struct", "enum class"]:
+                print("Error at %d: there are non-valid entries in the current block stack %s" % (self.lineno, self.block_stack))
                 sys.exit(-1)
             if block_name and (block_type == "namespace" or not qualified_name):
                 n += block_name + "."
@@ -598,7 +645,7 @@ class CppHeaderParser(object):
             n = "cv.Algorithm"
         return n
 
-    def parse_stmt(self, stmt, end_token):
+    def parse_stmt(self, stmt, end_token, mat="Mat", docstring=""):
         """
         parses the statement (ending with ';' or '}') or a block head (ending with '{')
 
@@ -645,7 +692,7 @@ class CppHeaderParser(object):
                     exit(1)
                 if classname.startswith("_Ipl"):
                     classname = classname[1:]
-                decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, []]
+                decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, [], None, docstring]
                 if bases:
                     decl[1] = ": " + ", ".join([self.get_dotted_name(b).replace(".","::") for b in bases])
                 return stmt_type, classname, True, decl
@@ -660,25 +707,24 @@ class CppHeaderParser(object):
                         exit(1)
                     decl = []
                     if ("CV_EXPORTS_W" in stmt) or ("CV_EXPORTS_AS" in stmt) or (not self.wrap_mode):# and ("CV_EXPORTS" in stmt)):
-                        decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, []]
+                        decl = [stmt_type + " " + self.get_dotted_name(classname), "", modlist, [], None, docstring]
                         if bases:
                             decl[1] = ": " + ", ".join([self.get_dotted_name(b).replace(".","::") for b in bases])
                     return stmt_type, classname, True, decl
 
-            if stmt.startswith("enum"):
-                return "enum", "", True, None
-
-            if stmt.startswith("namespace"):
-                stmt_list = stmt.split()
+            if stmt.startswith("enum") or stmt.startswith("namespace"):
+                stmt_list = stmt.rsplit(" ", 1)
                 if len(stmt_list) < 2:
                     stmt_list.append("<unnamed>")
                 return stmt_list[0], stmt_list[1], True, None
+
             if stmt.startswith("extern") and "\"C\"" in stmt:
                 return "namespace", "", True, None
 
-        if end_token == "}" and context == "enum":
+        if end_token == "}" and context.startswith("enum"):
             decl = self.parse_enum(stmt)
-            return "enum", "", False, decl
+            name = stack_top[self.BLOCK_NAME]
+            return context, name, False, decl
 
         if end_token == ";" and stmt.startswith("typedef"):
             # TODO: handle typedef's more intelligently
@@ -690,7 +736,7 @@ class CppHeaderParser(object):
             # since we filtered off the other places where '(' can normally occur:
             #   - code blocks
             #   - function pointer typedef's
-            decl = self.parse_func_decl(stmt)
+            decl = self.parse_func_decl(stmt, mat=mat, docstring=docstring)
             # we return parse_flag == False to prevent the parser to look inside function/method bodies
             # (except for tracking the nested blocks)
             return stmt_type, "", False, decl
@@ -717,7 +763,7 @@ class CppHeaderParser(object):
     def find_next_token(self, s, tlist, p=0):
         """
         Finds the next token from the 'tlist' in the input 's', starting from position 'p'.
-        Returns the first occured token and its position, or ("", len(s)) when no token is found
+        Returns the first occurred token and its position, or ("", len(s)) when no token is found
         """
         token = ""
         tpos = len(s)
@@ -737,7 +783,7 @@ class CppHeaderParser(object):
         """
         self.hname = hname
         decls = []
-        f = open(hname, "rt")
+        f = io.open(hname, 'rt', encoding='utf-8')
         linelist = list(f.readlines())
         f.close()
 
@@ -745,17 +791,19 @@ class CppHeaderParser(object):
         SCAN = 0 # outside of a comment or preprocessor directive
         COMMENT = 1 # inside a multi-line comment
         DIRECTIVE = 2 # inside a multi-line preprocessor directive
+        DOCSTRING = 3 # inside a multi-line docstring
 
         state = SCAN
 
         self.block_stack = [["file", hname, True, True, None]]
         block_head = ""
+        docstring = ""
         self.lineno = 0
         self.wrap_mode = wmode
 
         for l0 in linelist:
             self.lineno += 1
-            #print self.lineno
+            #print(state, self.lineno, l0)
 
             l = l0.strip()
 
@@ -775,8 +823,22 @@ class CppHeaderParser(object):
                 l = l[pos+2:]
                 state = SCAN
 
+            if state == DOCSTRING:
+                pos = l.find("*/")
+                if pos < 0:
+                    docstring += l + "\n"
+                    continue
+                docstring += l[:pos] + "\n"
+                l = l[pos+2:]
+                state = SCAN
+
+            if l.startswith('CV__') or l.startswith('__CV_'): # just ignore these lines
+                #print('IGNORE: ' + l)
+                state = SCAN
+                continue
+
             if state != SCAN:
-                print("Error at %d: invlid state = %d" % (self.lineno, state))
+                print("Error at %d: invalid state = %d" % (self.lineno, state))
                 sys.exit(-1)
 
             while 1:
@@ -784,19 +846,34 @@ class CppHeaderParser(object):
 
                 if not token:
                     block_head += " " + l
-                    break
+                    block_head = block_head.strip()
+                    if len(block_head) > 0 and block_head[-1] == ')' and block_head.startswith('CV_ENUM_FLAGS('):
+                        l = ''
+                        token = ';'
+                    else:
+                        break
 
                 if token == "//":
                     block_head += " " + l[:pos]
-                    break
+                    l = ''
+                    continue
 
                 if token == "/*":
                     block_head += " " + l[:pos]
-                    pos = l.find("*/", pos+2)
-                    if pos < 0:
+                    end_pos = l.find("*/", pos+2)
+                    if len(l) > pos + 2 and l[pos+2] == "*":
+                        # '/**', it's a docstring
+                        if end_pos < 0:
+                            state = DOCSTRING
+                            docstring = l[pos+3:] + "\n"
+                            break
+                        else:
+                            docstring = l[pos+3:end_pos]
+
+                    elif end_pos < 0:
                         state = COMMENT
                         break
-                    l = l[pos+2:]
+                    l = l[end_pos+2:]
                     continue
 
                 if token == "\"":
@@ -816,6 +893,7 @@ class CppHeaderParser(object):
 
                 stmt = (block_head + " " + l[:pos]).strip()
                 stmt = " ".join(stmt.split()) # normalize the statement
+                #print(stmt)
                 stack_top = self.block_stack[-1]
 
                 if stmt.startswith("@"):
@@ -826,13 +904,36 @@ class CppHeaderParser(object):
                 if stack_top[self.PROCESS_FLAG]:
                     # even if stack_top[PUBLIC_SECTION] is False, we still try to process the statement,
                     # since it can start with "public:"
-                    stmt_type, name, parse_flag, decl = self.parse_stmt(stmt, token)
+                    docstring = docstring.strip()
+                    stmt_type, name, parse_flag, decl = self.parse_stmt(stmt, token, docstring=docstring)
                     if decl:
-                        if stmt_type == "enum":
-                            for d in decl:
-                                decls.append(d)
+                        if stmt_type.startswith("enum"):
+                            decls.append([stmt_type + " " + self.get_dotted_name(name), "", [], decl, None, ""])
                         else:
                             decls.append(decl)
+
+                            if self._generate_gpumat_decls and "cv.cuda." in decl[0]:
+                                # If function takes as one of arguments Mat or vector<Mat> - we want to create the
+                                # same declaration working with GpuMat (this is important for T-Api access)
+                                args = decl[3]
+                                has_mat = len(list(filter(lambda x: x[0] in {"Mat", "vector_Mat"}, args))) > 0
+                                if has_mat:
+                                    _, _, _, gpumat_decl = self.parse_stmt(stmt, token, mat="cuda::GpuMat", docstring=docstring)
+                                    decls.append(gpumat_decl)
+
+                            if self._generate_umat_decls:
+                                # If function takes as one of arguments Mat or vector<Mat> - we want to create the
+                                # same declaration working with UMat (this is important for T-Api access)
+                                args = decl[3]
+                                has_mat = len(list(filter(lambda x: x[0] in {"Mat", "vector_Mat"}, args))) > 0
+                                if has_mat:
+                                    _, _, _, umat_decl = self.parse_stmt(stmt, token, mat="UMat", docstring=docstring)
+                                    decls.append(umat_decl)
+
+                        docstring = ""
+                    if stmt_type == "namespace":
+                        chunks = [block[1] for block in self.block_stack if block[0] == 'namespace'] + [name]
+                        self.namespaces.add('.'.join(chunks))
                 else:
                     stmt_type, name, parse_flag = "block", "", False
 
@@ -861,6 +962,8 @@ class CppHeaderParser(object):
         """
         for d in decls:
             print(d[0], d[1], ";".join(d[2]))
+            # Uncomment below line to see docstrings
+            # print('"""\n' + d[5] + '\n"""')
             for a in d[3]:
                 print("   ", a[0], a[1], a[2], end="")
                 if a[3]:
@@ -869,7 +972,7 @@ class CppHeaderParser(object):
                     print()
 
 if __name__ == '__main__':
-    parser = CppHeaderParser()
+    parser = CppHeaderParser(generate_umat_decls=True, generate_gpumat_decls=False)
     decls = []
   #  for hname in opencv_hdr_list:
   #      decls += parser.parse(hname)