Merge branch 'matlab' into matlab_public

Conflicts:
	CMakeLists.txt
	README.md
  samples/

CMakeLists.txt

@@ -43,7 +43,6 @@ if(DEFINED CMAKE_BUILD_TYPE)
 endif()
 
 project(OpenCV CXX C)
-
 include(cmake/OpenCVUtils.cmake)
 
 # ----------------------------------------------------------------------------
@@ -361,7 +360,6 @@ include(cmake/OpenCVFindLibsPerf.cmake)
 # ----------------------------------------------------------------------------
 #  Detect other 3rd-party libraries/tools
 # ----------------------------------------------------------------------------
-
 # --- LATEX for pdf documentation ---
 if(BUILD_DOCS)
   include(cmake/OpenCVFindLATEX.cmake)
@@ -393,6 +391,9 @@ if(WITH_OPENCL)
   include(cmake/OpenCVDetectOpenCL.cmake)
 endif()
 
+# --- Matlab/Octave ---
+include(cmake/OpenCVFindMatlab.cmake)
+
 # ----------------------------------------------------------------------------
 # Solution folders:
 # ----------------------------------------------------------------------------
@@ -829,6 +830,15 @@ if(NOT ANDROID)
 endif()
 status("    Java tests:"    BUILD_TESTS AND (CAN_BUILD_ANDROID_PROJECTS OR HAVE_opencv_java)            THEN YES ELSE NO)
 
+# ========================= matlab =========================
+status("")
+status("  Matlab:")
+status("    mex:"         MATLAB_MEX_SCRIPT  THEN  "${MATLAB_MEX_SCRIPT}"   ELSE NO)
+if (MATLAB_FOUND)
+  get_property(MEX_WORKS GLOBAL PROPERTY MEX_WORKS)
+  status("    Compiler/generator:" MEX_WORKS    THEN  "Working"                ELSE "Not working (bindings will not be generated)")
+endif()
+
 # ========================== documentation ==========================
 if(BUILD_DOCS)
   status("")

cmake/OpenCVFindMatlab.cmake

+# ----- Find Matlab/Octave -----
+#
+# OpenCVFindMatlab.cmake attempts to locate the install path of Matlab in order
+# to extract the mex headers, libraries and shell scripts. If found 
+# successfully, the following variables will be defined
+#
+#   MATLAB_FOUND:       true/false
+#   MATLAB_ROOT_DIR:    Root of Matlab installation
+#   MATLAB_BIN:         The main Matlab "executable" (shell script)
+#   MATLAB_MEX_SCRIPT:  The mex script used to compile mex files
+#   MATLAB_BIN:         The actual Matlab executable
+#   MATLAB_INCLUDE_DIR: Path to "mex.h"
+#   MATLAB_LIBRARY_DIR: Path to mex and matrix libraries
+#   MATLAB_LIBS:        The Matlab libs, usually mx, mex, mat
+#   MATLAB_MEXEXT:      The mex library extension. It will be one of:
+#                         mexwin32, mexwin64,  mexglx, mexa64, mexmac, 
+#                         mexmaci,  mexmaci64, mexsol, mexs64
+#   MATLAB_ARCH:        The installation architecture. It is simply
+#                       the MEXEXT with the preceding "mex" removed
+#
+# There doesn't appear to be an elegant way to detect all versions of Matlab
+# across different platforms. If you know the matlab path and want to avoid
+# the search, you can define the path to the Matlab root when invoking cmake:
+#
+#   cmake -DMATLAB_ROOT_DIR='/PATH/TO/ROOT_DIR' ..
+
+
+
+# ----- set_library_presuffix -----
+#
+# Matlab tends to use some non-standard prefixes and suffixes on its libraries.
+# For example, libmx.dll on Windows (Windows does not add prefixes) and
+# mkl.dylib on OS X (OS X uses "lib" prefixes). 
+# On some versions of Windows the .dll suffix also appears to not be checked.
+#
+# This function modifies the library prefixes and suffixes used by 
+# find_library when finding Matlab libraries. It does not affect scopes
+# outside of this file.
+function(set_libarch_prefix_suffix)
+	if (UNIX AND NOT APPLE)
+		set(CMAKE_FIND_LIBRARY_PREFIXES "lib" PARENT_SCOPE)
+		set(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a" PARENT_SCOPE)
+	elseif (APPLE)
+		set(CMAKE_FIND_LIBRARY_PREFIXES "lib" PARENT_SCOPE)
+		set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".a" PARENT_SCOPE)
+	elseif (WIN32)
+		set(CMAKE_FIND_LIBRARY_PREFIXES "lib" PARENT_SCOPE)
+		set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll" PARENT_SCOPE)
+	endif()
+endfunction()
+
+
+
+# ----- locate_matlab_root -----
+#
+# Attempt to find the path to the Matlab installation. If successful, sets
+# the absolute path in the variable MATLAB_ROOT_DIR
+function(locate_matlab_root)
+	
+  # --- LINUX ---
+  if (UNIX AND NOT APPLE)
+    # possible root locations, in order of likelihood
+    set(SEARCH_DIRS_ /usr/local /opt/local /usr /opt)
+    foreach (DIR_ ${SEARCH_DIRS_})
+      file(GLOB MATLAB_ROOT_DIR_ ${DIR_}/*matlab*)
+      if (MATLAB_ROOT_DIR_)
+        # sort in order from highest to lowest
+        list(SORT MATLAB_ROOT_DIR_)
+        list(REVERSE MATLAB_ROOT_DIR_)
+        list(GET MATLAB_ROOT_DIR_ 0 MATLAB_ROOT_DIR_)
+        break()
+      endif()
+    endforeach()
+
+  # --- APPLE ---
+  elseif (APPLE)
+    # possible root locations, in order of likelihood
+    set(SEARCH_DIRS_ /Applications /usr/local /opt/local /usr /opt)
+    foreach (DIR_ ${SEARCH_DIRS_})
+      file(GLOB MATLAB_ROOT_DIR_ ${DIR_}/*matlab*)
+      if (MATLAB_ROOT_DIR_)
+        # sort in order from highest to lowest
+        # normally it's in the format MATLAB_R[20XX][A/B]
+        list(SORT MATLAB_ROOT_DIR_)
+        list(REVERSE MATLAB_ROOT_DIR_)
+        list(GET MATLAB_ROOT_DIR_ 0 MATLAB_ROOT_DIR_)
+        break()
+      endif()
+    endforeach()
+
+  # --- WINDOWS ---
+  elseif (WIN32)
+		# search the path to see if Matlab exists there
+		# fingers crossed it is, otherwise we have to start hunting through the registry :/
+		string(REGEX REPLACE ".*[;=](.*[Mm][Aa][Tt][Ll][Aa][Bb][^;]*)\\\\bin.*" "\\1" MATLAB_ROOT_DIR_ "$ENV{PATH}")
+		
+	  # registry-hacking	
+    # determine the available Matlab versions
+		set(REG_EXTENSION_ "SOFTWARE\\Mathworks\\MATLAB")
+    set(REG_ROOTS_ "HKEY_LOCAL_MACHINE" "HKEY_CURRENT_USER")
+    foreach(REG_ROOT_ ${REG_ROOTS_})
+			execute_process(COMMAND reg query "${REG_ROOT_}\\${REG_EXTENSION_}" OUTPUT_VARIABLE QUERY_RESPONSE_)
+			if (QUERY_RESPONSE_)
+        string(REGEX MATCHALL "[0-9]\\.[0-9]" VERSION_STRINGS_ ${QUERY_RESPONSE_})
+        list(APPEND VERSIONS_ ${VERSION_STRINGS_})
+			endif()
+		endforeach()
+		
+		# select the highest version
+		list(APPEND VERSIONS_ "0.0")
+		list(SORT VERSIONS_)
+		list(REVERSE VERSIONS_)
+		list(GET VERSIONS_ 0 VERSION_)
+		
+		# request the MATLABROOT from the registry
+		foreach(REG_ROOT_ ${REG_ROOTS_})
+			get_filename_component(QUERY_RESPONSE_ [${REG_ROOT_}\\${REG_EXTENSION_}\\${VERSION_};MATLABROOT] ABSOLUTE)
+			if (NOT ${MATLAB_ROOT_DIR_} AND NOT ${QUERY_RESPONSE_} MATCHES "registry$")
+				set(MATLAB_ROOT_DIR_ ${QUERY_RESPONSE_})
+			endif()
+		endforeach()
+	endif()
+
+  # export the root into the parent scope
+  if (MATLAB_ROOT_DIR_)
+    set(MATLAB_ROOT_DIR ${MATLAB_ROOT_DIR_} PARENT_SCOPE)
+  endif()
+endfunction()
+
+
+
+# ----- locate_matlab_components -----
+#
+# Given a directory MATLAB_ROOT_DIR, attempt to find the Matlab components
+# (include directory and libraries) under the root. If everything is found,
+# sets the variable MATLAB_FOUND to TRUE
+function(locate_matlab_components MATLAB_ROOT_DIR)
+  # get the mex extension
+  if (UNIX)
+    execute_process(COMMAND ${MATLAB_ROOT_DIR}/bin/mexext OUTPUT_VARIABLE MATLAB_MEXEXT_)
+  elseif (WIN32)
+    execute_process(COMMAND ${MATLAB_ROOT_DIR}/bin/mexext.bat OUTPUT_VARIABLE MATLAB_MEXEXT_)
+  endif()
+  if (NOT MATLAB_MEXEXT_)
+    return()
+  endif()
+  string(STRIP ${MATLAB_MEXEXT_} MATLAB_MEXEXT_)
+	
+	# map the mexext to an architecture extension
+	set(ARCHITECTURES_ "maci64" "maci" "glnxa64" "glnx64" "sol64" "sola64" "win32" "win64" )
+	foreach(ARCHITECTURE_ ${ARCHITECTURES_})
+		if(EXISTS ${MATLAB_ROOT_DIR}/bin/${ARCHITECTURE_})
+			set(MATLAB_ARCH_ ${ARCHITECTURE_})
+			break()
+		endif()
+	endforeach()
+
+  # get the path to the libraries
+  set(MATLAB_LIBRARY_DIR_ ${MATLAB_ROOT_DIR}/bin/${MATLAB_ARCH_})
+	
+  # get the libraries
+	set_libarch_prefix_suffix()
+  find_library(MATLAB_LIB_MX_  mx  PATHS ${MATLAB_LIBRARY_DIR_} NO_DEFAULT_PATH)
+  find_library(MATLAB_LIB_MEX_ mex PATHS ${MATLAB_LIBRARY_DIR_} NO_DEFAULT_PATH)
+  find_library(MATLAB_LIB_MAT_ mat PATHS ${MATLAB_LIBRARY_DIR_} NO_DEFAULT_PATH)
+  set(MATLAB_LIBS_ ${MATLAB_LIB_MX_} ${MATLAB_LIB_MEX_} ${MATLAB_LIB_MAT_})
+
+  # get the include path
+  find_path(MATLAB_INCLUDE_DIR_ mex.h ${MATLAB_ROOT_DIR}/extern/include) 
+
+  # get the mex shell script
+  find_file(MATLAB_MEX_SCRIPT_ NAMES mex mex.bat PATHS ${MATLAB_ROOT_DIR}/bin NO_DEFAULT_PATH)
+
+  # get the Matlab executable
+  find_file(MATLAB_BIN_ NAMES matlab matlab.exe PATHS ${MATLAB_ROOT_DIR}/bin NO_DEFAULT_PATH)
+
+  # export into parent scope
+  if (MATLAB_MEX_SCRIPT_ AND MATLAB_LIBS_ AND MATLAB_INCLUDE_DIR_)
+    set(MATLAB_BIN         ${MATLAB_BIN_}         PARENT_SCOPE)
+    set(MATLAB_MEX_SCRIPT  ${MATLAB_MEX_SCRIPT_}  PARENT_SCOPE)
+    set(MATLAB_INCLUDE_DIR ${MATLAB_INCLUDE_DIR_} PARENT_SCOPE)
+    set(MATLAB_LIBS        ${MATLAB_LIBS_}        PARENT_SCOPE)
+    set(MATLAB_LIBRARY_DIR ${MATLAB_LIBRARY_DIR_} PARENT_SCOPE)
+    set(MATLAB_MEXEXT      ${MATLAB_MEXEXT_}      PARENT_SCOPE)
+    set(MATLAB_ARCH        ${MATLAB_ARCH_}        PARENT_SCOPE)
+  endif()
+  return()
+endfunction()
+
+
+
+# ----------------------------------------------------------------------------
+# FIND MATLAB COMPONENTS
+# ----------------------------------------------------------------------------
+if (NOT MATLAB_FOUND)
+ 
+  # guilty until proven innocent
+  set(MATLAB_FOUND FALSE)
+
+  # attempt to find the Matlab root folder
+  if (NOT MATLAB_ROOT_DIR)
+    locate_matlab_root()
+  endif()
+
+  # given the matlab root folder, find the library locations 
+  if (MATLAB_ROOT_DIR)
+    locate_matlab_components(${MATLAB_ROOT_DIR})
+  endif()
+  find_package_handle_standard_args(Matlab DEFAULT_MSG MATLAB_MEX_SCRIPT MATLAB_INCLUDE_DIR 
+                                           MATLAB_ROOT_DIR MATLAB_LIBS   MATLAB_LIBRARY_DIR 
+                                           MATLAB_MEXEXT MATLAB_ARCH MATLAB_BIN)
+endif()

modules/matlab/LICENSE

+////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this
+//  license. If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote
+//     products derived from this software without specific prior written
+//     permission.
+//
+// This software is provided by the copyright holders and contributors "as is"
+// and any express or implied warranties, including, but not limited to, the
+// implied warranties of merchantability and fitness for a particular purpose
+// are disclaimed. In no event shall the Intel Corporation or contributors be
+// liable for any direct, indirect, incidental, special, exemplary, or
+// consequential damages (including, but not limited to, procurement of
+// substitute goods or services; loss of use, data, or profits; or business
+// interruption) however caused and on any theory of liability, whether in
+// contract, strict liability, or tort (including negligence or otherwise)
+// arising in any way out of the use of this software, even if advised of the
+// possibility of such damage.
+//
+////////////////////////////////////////////////////////////////////////////////
\ No newline at end of file

modules/matlab/compile.cmake

+# LISTIFY
+# Given a string of space-delimited tokens, reparse as a string of
+# semi-colon delimited tokens, which in CMake land is exactly equivalent
+# to a list
+macro(listify OUT_LIST IN_STRING)
+    string(REPLACE " " ";" ${OUT_LIST} ${IN_STRING})
+endmacro()
+
+# listify multiple-argument inputs
+listify(MEX_INCLUDE_DIRS_LIST ${MEX_INCLUDE_DIRS})
+if (${CONFIGURATION} MATCHES "Debug")
+    listify(MEX_LIBS_LIST ${MEX_DEBUG_LIBS})
+else()
+    listify(MEX_LIBS_LIST ${MEX_LIBS})
+endif()
+
+# if it's MSVC building a Debug configuration, don't build bindings
+if ("${CONFIGURATION}" MATCHES "Debug")
+    message(STATUS "Matlab bindings are only available in Release configurations. Skipping...")
+    return()
+endif()
+
+# for each generated source file:
+# 1. check if the file has already been compiled
+# 2. attempt compile if required
+# 3. if the compile fails, throw an error and cancel compilation
+file(GLOB SOURCE_FILES "${CMAKE_CURRENT_BINARY_DIR}/src/*.cpp")
+foreach(SOURCE_FILE ${SOURCE_FILES})
+    # strip out the filename
+    get_filename_component(FILENAME ${SOURCE_FILE} NAME_WE)
+    # compile the source file using mex
+    execute_process(COMMAND echo ${FILENAME})
+    if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/+cv/${FILENAME}.${MATLAB_MEXEXT})
+        execute_process(
+            COMMAND ${MATLAB_MEX_SCRIPT} ${MEX_OPTS} "CXXFLAGS=\$CXXFLAGS ${MEX_CXXFLAGS}" ${MEX_INCLUDE_DIRS_LIST} 
+                    ${MEX_LIB_DIR} ${MEX_LIBS_LIST} ${SOURCE_FILE}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/+cv
+            OUTPUT_QUIET
+            ERROR_VARIABLE FAILED
+        )
+    endif()
+    # TODO: If a mex file fails to compile, should we error out?
+    if (FAILED)
+        message(FATAL_ERROR "Failed to compile ${FILENAME}: ${FAILED}")
+    endif()
+endforeach()

modules/matlab/generator/build_info.py

+#!/usr/bin/env python
+
+def substitute(build, output_dir):
+
+    # 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 filters
+    jtemplate.filters['csv'] = csv
+    jtemplate.filters['stripExtraSpaces'] = stripExtraSpaces
+
+    # load the template
+    template = jtemplate.get_template('template_build_info.m')
+
+    # create the build directory
+    output_dir  = output_dir+'/+cv'
+    if not os.path.isdir(output_dir):
+      os.mkdir(output_dir)
+
+    # populate template
+    populated = template.render(build=build, time=time)
+    with open(os.path.join(output_dir, 'buildInformation.m'), 'wb') as f:
+        f.write(populated)
+
+if __name__ == "__main__":
+    """
+    Usage: python build_info.py --os os_version_string
+                                --arch [bitness processor]
+                                --compiler [id version]
+                                --mex_arch arch_string
+                                --mex_script /path/to/mex/script
+                                --cxx_flags [-list -of -flags -to -passthrough]
+                                --opencv_version version_string
+                                --commit commit_hash_if_using_git
+                                --modules [core imgproc highgui etc]
+                                --configuration Debug/Release
+                                --outdir /path/to/write/build/info
+
+    build_info.py generates a Matlab function that can be invoked with a call to
+      >> cv.buildInformation();
+
+    This function prints a summary of the user's OS, OpenCV and Matlab build
+    given the information passed to this module. build_info.py invokes Jinja2
+    on the template_build_info.m template.
+    """
+   
+    # parse the input options
+    import sys, re, os, time 
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('--os')
+    parser.add_argument('--arch', nargs=2)
+    parser.add_argument('--compiler', nargs='+')
+    parser.add_argument('--mex_arch')
+    parser.add_argument('--mex_script')
+    parser.add_argument('--mex_opts', default=['-largeArrayDims'], nargs='*')
+    parser.add_argument('--cxx_flags', default=[], nargs='*')
+    parser.add_argument('--opencv_version', default='', nargs='?')
+    parser.add_argument('--commit', default='Not in working git tree', nargs='?')
+    parser.add_argument('--modules', nargs='+')
+    parser.add_argument('--configuration')
+    parser.add_argument('--outdir')
+    build = parser.parse_args()
+
+    from filters import *
+    from jinja2 import Environment, FileSystemLoader
+
+    # populate the build info template
+    substitute(build, build.outdir)

modules/matlab/generator/cvmex.py

+#!/usr/bin/env python
+
+def substitute(cv, output_dir):
+
+    # 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 filters
+    jtemplate.filters['cellarray'] = cellarray
+    jtemplate.filters['split'] = split
+    jtemplate.filters['csv'] = csv
+
+    # load the template
+    template = jtemplate.get_template('template_cvmex_base.m')
+
+    # create the build directory
+    output_dir  = output_dir+'/+cv'
+    if not os.path.isdir(output_dir):
+      os.mkdir(output_dir)
+
+    # populate template
+    populated = template.render(cv=cv, time=time)
+    with open(os.path.join(output_dir, 'mex.m'), 'wb') as f:
+        f.write(populated)
+
+if __name__ == "__main__":
+    """
+    Usage: python cvmex.py  --opts [-list -of -opts]
+                            --include_dirs [-list -of -opencv_include_directories]
+                            --lib_dir opencv_lib_directory
+                            --libs [-lopencv_core -lopencv_imgproc ...]
+                            --flags [-Wall -opencv_build_flags ...]
+                            --outdir /path/to/generated/output
+
+    cvmex.py generates a custom mex compiler that automatically links OpenCV
+    libraries to built sources where appropriate. The calling syntax is the
+    same as the builtin mex compiler, with added cv qualification:
+      >> cv.mex(..., ...);
+    """
+   
+    # parse the input options
+    import sys, re, os, time
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('--opts')
+    parser.add_argument('--include_dirs')
+    parser.add_argument('--lib_dir')
+    parser.add_argument('--libs')
+    parser.add_argument('--flags')
+    parser.add_argument('--outdir')
+    cv = parser.parse_args()
+
+    from filters import *
+    from jinja2 import Environment, FileSystemLoader
+
+    # populate the mex base template
+    substitute(cv, cv.outdir)

modules/matlab/generator/filters.py

+from textwrap import TextWrapper
+from string import split, join
+import re, os
+# precompile a URL matching regular expression
+urlexpr = re.compile(r"((https?):((//)|(\\\\))+[\w\d:#@%/;$()~_?\+-=\\\.&]*)", re.MULTILINE|re.UNICODE)
+
+def inputs(args):
+    '''Keeps only the input arguments in a list of elements.
+    In OpenCV input arguments are all arguments with names
+    not beginning with 'dst'
+    '''
+    try:
+      return [arg for arg in args['only'] if arg.I and not arg.O]
+    except:
+      return [arg for arg in args if arg.I]
+
+def ninputs(fun):
+    '''Counts the number of input arguments in the input list'''
+    return len(inputs(fun.req)) + len(inputs(fun.opt))
+
+def outputs(args):
+    '''Determines whether any of the given arguments is an output
+    reference, and returns a list of only those elements.
+    In OpenCV, output references are preceeded by 'dst'
+    '''
+    try:
+      return [arg for arg in args['only'] if arg.O and not arg.I]
+    except:
+      return [arg for arg in args if arg.O]
+
+def only(args):
+    '''Returns exclusively the arguments which are only inputs
+    or only outputs'''
+    d = {};
+    d['only'] = args
+    return d
+
+def void(arg):
+    '''Is the input 'void' '''
+    return arg == 'void'
+
+def flip(arg):
+    '''flip the sign of the input'''
+    return not arg
+
+def noutputs(fun):
+    '''Counts the number of output arguments in the input list'''
+    return int(not void(fun.rtp)) + len(outputs(fun.req)) + len(outputs(fun.opt))
+
+def convertibleToInt(string):
+    '''Can the input string be evaluated to an integer?'''
+    salt = '1+'
+    try:
+        exec(salt+string)
+        return True
+    except:
+        return False
+
+def binaryToDecimal(string):
+    '''Attempt to convert the input string to floating point representation'''
+    try:
+        return str(eval(string))
+    except:
+        return string
+
+def formatMatlabConstant(string, table):
+    '''
+    Given a string representing a Constant, and a table of all Constants, 
+    attempt to resolve the Constant into a valid Matlab expression
+    For example, the input
+      DEPENDENT_VALUE = 1 << FIXED_VALUE
+    needs to be converted to
+      DEPENDENT_VALUE = bitshift(1, cv.FIXED_VALUE);
+    '''
+    # split the string into expressions
+    words = re.split('(\W+)', string)
+    # add a 'cv' prefix if an expression is also a key in the lookup table
+    words = ''.join([('cv.'+word if word in table else word) for word in words]) 
+    # attempt to convert arithmetic expressions and binary/hex to decimal
+    words = binaryToDecimal(words)
+    # convert any remaining bitshifts to Matlab 'bitshift' methods
+    shift = re.sub('[\(\) ]', '', words).split('<<')
+    words = 'bitshift('+shift[0]+', '+shift[1]+')' if len(shift) == 2 else words
+    return words
+
+def matlabURL(string):
+    """This filter is used to construct a Matlab specific URL that calls the
+    system browser instead of the (insanely bad) builtin Matlab browser"""
+    return re.sub(urlexpr, '<a href="matlab: web(\'\\1\', \'-browser\')">\\1</a>', string)
+
+def capitalizeFirst(text):
+    '''Capitalize only the first character of the text string'''
+    return text[0].upper() + text[1:]
+
+def toUpperCamelCase(text):
+    '''variable_name --> VariableName'''
+    return ''.join([capitalizeFirst(word) for word in text.split('_')])
+
+def toLowerCamelCase(text):
+    '''variable_name --> variableName'''
+    upper_camel = toUpperCamelCase(test)
+    return upper_camel[0].lower() + upper_camel[1:]
+
+def toUnderCase(text):
+    '''VariableName --> variable_name'''
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+def stripTags(text):
+    '''
+    strip or convert html tags from a text string
+    <code>content</code> --> content
+    <anything>           --> ''
+    &lt                  --> <
+    &gt                  --> >
+    &le                  --> <=
+    &ge                  --> >=
+    '''
+    upper = lambda pattern: pattern.group(1).upper()
+    text = re.sub('<code>(.*?)</code>', upper, text)
+    text = re.sub('<([^=\s].*?)>', '', text)
+    text = re.sub('&lt', '<', text)
+    text = re.sub('&gt', '>', text)
+    text = re.sub('&le', '<=', text)
+    text = re.sub('&ge', '>=', text)
+    return text
+
+def qualify(text, name):
+    '''Adds uppercase 'CV.' qualification to any occurrences of name in text'''
+    return re.sub(name.upper(), 'CV.'+name.upper(), text)
+
+def slugify(text):
+    '''A_Function_name --> a-function-name'''
+    return text.lower().replace('_', '-')
+
+def filename(fullpath):
+    '''Returns only the filename without an extension from a file path
+    eg. /path/to/file.txt --> file
+    '''
+    return os.path.splitext(os.path.basename(fullpath))[0]
+
+def split(text, delimiter=' '):
+    '''Split a text string into a list using the specified delimiter'''
+    return text.split(delimiter)
+
+def csv(items, sep=', '):
+    '''format a list with a separator (comma if not specified)'''
+    return sep.join(item for item in items)
+
+def cellarray(items, escape='\''):
+    '''format a list of items as a matlab cell array'''
+    return '{' + ', '.join(escape+item+escape for item in items) + '}'
+
+def stripExtraSpaces(text):
+    '''Removes superfluous whitespace from a string, including the removal
+    of all leading and trailing whitespace'''
+    return ' '.join(text.split())
+    
+def comment(text, wrap=80, escape='% ', escape_first='', escape_last=''):
+    '''comment filter
+    Takes a string in text, and wraps it to wrap characters in length with
+    preceding comment escape sequence on each line. escape_first and 
+    escape_last can be used for languages which define block comments.
+    Examples:
+        C++ inline comment    comment(80, '// ')
+        C block comment:      comment(80, ' * ', '/*', ' */')
+        Matlab comment:       comment(80, '% ')
+        Matlab block comment: comment(80, '', '%{', '%}')
+        Python docstrings:    comment(80, '', '\'\'\'', '\'\'\'')
+    '''
+
+    tw = TextWrapper(width=wrap-len(escape))
+    if escape_first:
+        escape_first = escape_first+'\n'
+    if escape_last:
+        escape_last = '\n'+escape_last
+    escapn = '\n'+escape
+    lines  = text.split('\n')
+    wlines = (tw.wrap(line) for line in lines)
+    return escape_first+escape+join((join(line, escapn) for line in wlines), escapn)+escape_last

modules/matlab/generator/gen_matlab.py

+#!/usr/bin/env python
+
+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_root, 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.
+        """
+        # parse each of the files and store in a dictionary
+        # as a separate "namespace"
+        parser = CppHeaderParser()
+        rst    = rst_parser.RstParser(parser)
+        rst_parser.verbose = False
+        rst_parser.show_warnings = False
+        rst_parser.show_errors = False
+        rst_parser.show_critical_errors = False
+
+        ns  = dict((key, []) for key in modules)
+        doc = dict((key, []) for key in modules)
+        path_template = Template('${module}/include/opencv2/${module}.hpp')
+
+        for module in modules:
+            # construct a header path from the module root and a path template
+            header = os.path.join(module_root, path_template.substitute(module=module))
+            # parse the definitions
+            ns[module] = parser.parse(header)
+            # parse the documentation
+            rst.parse(module, os.path.join(module_root, module))
+            doc[module] = rst.definitions
+            rst.definitions = {}
+
+        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')
+        tdoc       = jtemplate.get_template('template_doc_base.m')
+        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.mkdir(output_source_dir)
+        if not os.path.isdir(output_private_dir):
+          os.mkdir(output_private_dir)
+        if not os.path.isdir(output_class_dir):
+          os.mkdir(output_class_dir)
+        if not os.path.isdir(output_map_dir):
+          os.mkdir(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)
+                with open(output_source_dir+'/'+method.name+'.cpp', 'wb') as f:
+                    f.write(populated)
+                if namespace.name in doc and method.name in doc[namespace.name]:
+                    populated = tdoc.render(fun=method, doc=doc[namespace.name][method.name], time=time)
+                    with open(output_class_dir+'/'+method.name+'.m', 'wb') as f:
+                        f.write(populated)
+            # classes
+            for clss in namespace.classes:
+                # cpp converter
+                populated = tclassc.render(clss=clss, time=time)
+                with open(output_private_dir+'/'+clss.name+'Bridge.cpp', 'wb') as f:
+                    f.write(populated)
+                # matlab classdef
+                populated = tclassm.render(clss=clss, time=time)
+                with open(output_class_dir+'/'+clss.name+'.m', 'wb') as f:
+                    f.write(populated)
+
+        # create a global constants lookup table
+        const = dict(constants(todict(parse_tree.namespaces)))
+        populated = tconst.render(constants=const, time=time)
+        with open(output_dir+'/cv.m', 'wb') as f:
+            f.write(populated)
+
+
+if __name__ == "__main__":
+    """
+    Usage: python gen_matlab.py --hdrparser /path/to/hdr_parser/dir
+                                --rstparser /path/to/rst_parser/dir
+                                --moduleroot /path/to/opencv/modules
+                                --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. parses .rst docs using RstParser 
+      5. populates the templates for classes, function, enums and docs from the
+         definitions
+
+    gen_matlab.py requires the following inputs:
+    --hdrparser    the path to the header parser directory
+                   (opencv/modules/python/src2)
+    --rstparser    the path to the rst parser directory
+                   (opencv/modules/java/generator)
+    --moduleroot   (optional) path to the opencv directory 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
+    import sys, re, os, time
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('--hdrparser')
+    parser.add_argument('--rstparser')
+    parser.add_argument('--moduleroot', 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 and rst_parser modules to the path
+    sys.path.append(args.hdrparser)
+    sys.path.append(args.rstparser)
+
+    from string import Template
+    from hdr_parser import CppHeaderParser
+    import rst_parser
+    from parse_tree import ParseTree, todict, constants
+    from filters import *
+    from jinja2 import Environment, FileSystemLoader
+
+    # create the generator
+    mwg = MatlabWrapperGenerator()
+    mwg.gen(args.moduleroot, args.modules, args.extra, args.outdir)

modules/matlab/generator/jinja2/AUTHORS

+Jinja is written and maintained by the Jinja Team and various
+contributors:
+
+Lead Developer:
+
+- Armin Ronacher <armin.ronacher@active-4.com>
+
+Developers:
+
+- Christoph Hack
+- Georg Brandl
+
+Contributors:
+
+- Bryan McLemore
+- Mickaël Guérin <kael@crocobox.org>
+- Cameron Knight
+- Lawrence Journal-World.
+- David Cramer
+
+Patches and suggestions:
+
+- Ronny Pfannschmidt
+- Axel Böhm
+- Alexey Melchakov
+- Bryan McLemore
+- Clovis Fabricio (nosklo)
+- Cameron Knight
+- Peter van Dijk (Habbie)
+- Stefan Ebner
+- Rene Leonhardt
+- Thomas Waldmann
+- Cory Benfield (Lukasa)

modules/matlab/generator/jinja2/LICENSE

+Copyright (c) 2009 by the Jinja Team, see AUTHORS for more details.
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * The names of the contributors may not be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

modules/matlab/generator/jinja2/__init__.py

+# -*- coding: utf-8 -*-
+"""
+    jinja2
+    ~~~~~~
+
+    Jinja2 is a template engine written in pure Python.  It provides a
+    Django inspired non-XML syntax but supports inline expressions and
+    an optional sandboxed environment.
+
+    Nutshell
+    --------
+
+    Here a small example of a Jinja2 template::
+
+        {% extends 'base.html' %}
+        {% block title %}Memberlist{% endblock %}
+        {% block content %}
+          <ul>
+          {% for user in users %}
+            <li><a href="{{ user.url }}">{{ user.username }}</a></li>
+          {% endfor %}
+          </ul>
+        {% endblock %}
+
+
+    :copyright: (c) 2010 by the Jinja Team.
+    :license: BSD, see LICENSE for more details.
+"""
+__docformat__ = 'restructuredtext en'
+__version__ = '2.8-dev'
+
+# high level interface
+from jinja2.environment import Environment, Template
+
+# loaders
+from jinja2.loaders import BaseLoader, FileSystemLoader, \
+     DictLoader, FunctionLoader, PrefixLoader, ChoiceLoader, \
+     ModuleLoader
+
+# bytecode caches
+from jinja2.bccache import BytecodeCache, FileSystemBytecodeCache, \
+     MemcachedBytecodeCache
+
+# undefined types
+from jinja2.runtime import Undefined, DebugUndefined, StrictUndefined
+
+# exceptions
+from jinja2.exceptions import TemplateError, UndefinedError, \
+     TemplateNotFound, TemplatesNotFound, TemplateSyntaxError, \
+     TemplateAssertionError
+
+# decorators and public utilities
+from jinja2.filters import environmentfilter, contextfilter, \
+     evalcontextfilter
+from jinja2.utils import Markup, escape, clear_caches, \
+     environmentfunction, evalcontextfunction, contextfunction, \
+     is_undefined
+
+__all__ = [
+    'Environment', 'Template', 'BaseLoader', 'FileSystemLoader',
+    'DictLoader', 'FunctionLoader', 'PrefixLoader',
+    'ChoiceLoader', 'BytecodeCache', 'FileSystemBytecodeCache',
+    'MemcachedBytecodeCache', 'Undefined', 'DebugUndefined',
+    'StrictUndefined', 'TemplateError', 'UndefinedError', 'TemplateNotFound',
+    'TemplatesNotFound', 'TemplateSyntaxError', 'TemplateAssertionError',
+    'ModuleLoader', 'environmentfilter', 'contextfilter', 'Markup', 'escape',
+    'environmentfunction', 'contextfunction', 'clear_caches', 'is_undefined',
+    'evalcontextfilter', 'evalcontextfunction'
+]

modules/matlab/generator/jinja2/_compat.py

+# -*- coding: utf-8 -*-
+"""
+    jinja2._compat
+    ~~~~~~~~~~~~~~
+
+    Some py2/py3 compatibility support based on a stripped down
+    version of six so we don't have to depend on a specific version
+    of it.
+
+    :copyright: Copyright 2013 by the Jinja team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+import sys
+
+PY2 = sys.version_info[0] == 2
+PYPY = hasattr(sys, 'pypy_translation_info')
+_identity = lambda x: x
+
+
+if not PY2:
+    unichr = chr
+    range_type = range
+    text_type = str
+    string_types = (str,)
+
+    iterkeys = lambda d: iter(d.keys())
+    itervalues = lambda d: iter(d.values())
+    iteritems = lambda d: iter(d.items())
+
+    import pickle
+    from io import BytesIO, StringIO
+    NativeStringIO = StringIO
+
+    def reraise(tp, value, tb=None):
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+    ifilter = filter
+    imap = map
+    izip = zip
+    intern = sys.intern
+
+    implements_iterator = _identity
+    implements_to_string = _identity
+    encode_filename = _identity
+    get_next = lambda x: x.__next__
+
+else:
+    unichr = unichr
+    text_type = unicode
+    range_type = xrange
+    string_types = (str, unicode)
+
+    iterkeys = lambda d: d.iterkeys()
+    itervalues = lambda d: d.itervalues()
+    iteritems = lambda d: d.iteritems()
+
+    import cPickle as pickle
+    from cStringIO import StringIO as BytesIO, StringIO
+    NativeStringIO = BytesIO
+
+    exec('def reraise(tp, value, tb=None):\n raise tp, value, tb')
+
+    from itertools import imap, izip, ifilter
+    intern = intern
+
+    def implements_iterator(cls):
+        cls.next = cls.__next__
+        del cls.__next__
+        return cls
+
+    def implements_to_string(cls):
+        cls.__unicode__ = cls.__str__
+        cls.__str__ = lambda x: x.__unicode__().encode('utf-8')
+        return cls
+
+    get_next = lambda x: x.next
+
+    def encode_filename(filename):
+        if isinstance(filename, unicode):
+            return filename.encode('utf-8')
+        return filename
+
+
+def with_metaclass(meta, *bases):
+    # This requires a bit of explanation: the basic idea is to make a
+    # dummy metaclass for one level of class instanciation that replaces
+    # itself with the actual metaclass.  Because of internal type checks
+    # we also need to make sure that we downgrade the custom metaclass
+    # for one level to something closer to type (that's why __call__ and
+    # __init__ comes back from type etc.).
+    #
+    # This has the advantage over six.with_metaclass in that it does not
+    # introduce dummy classes into the final MRO.
+    class metaclass(meta):
+        __call__ = type.__call__
+        __init__ = type.__init__
+        def __new__(cls, name, this_bases, d):
+            if this_bases is None:
+                return type.__new__(cls, name, (), d)
+            return meta(name, bases, d)
+    return metaclass('temporary_class', None, {})
+
+
+try:
+    from urllib.parse import quote_from_bytes as url_quote
+except ImportError:
+    from urllib import quote as url_quote

modules/matlab/generator/jinja2/defaults.py

+# -*- coding: utf-8 -*-
+"""
+    jinja2.defaults
+    ~~~~~~~~~~~~~~~
+
+    Jinja default filters and tags.
+
+    :copyright: (c) 2010 by the Jinja Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from jinja2._compat import range_type
+from jinja2.utils import generate_lorem_ipsum, Cycler, Joiner
+
+
+# defaults for the parser / lexer
+BLOCK_START_STRING = '{%'
+BLOCK_END_STRING = '%}'
+VARIABLE_START_STRING = '{{'
+VARIABLE_END_STRING = '}}'
+COMMENT_START_STRING = '{#'
+COMMENT_END_STRING = '#}'
+LINE_STATEMENT_PREFIX = None
+LINE_COMMENT_PREFIX = None
+TRIM_BLOCKS = False
+LSTRIP_BLOCKS = False
+NEWLINE_SEQUENCE = '\n'
+KEEP_TRAILING_NEWLINE = False
+
+
+# default filters, tests and namespace
+from jinja2.filters import FILTERS as DEFAULT_FILTERS
+DEFAULT_NAMESPACE = {
+    'range':        range_type,
+    'dict':         lambda **kw: kw,
+    'lipsum':       generate_lorem_ipsum,
+    'cycler':       Cycler,
+    'joiner':       Joiner
+}
+
+
+# export all constants
+__all__ = tuple(x for x in locals().keys() if x.isupper())

modules/matlab/generator/jinja2/exceptions.py

+# -*- coding: utf-8 -*-
+"""
+    jinja2.exceptions
+    ~~~~~~~~~~~~~~~~~
+
+    Jinja exceptions.
+
+    :copyright: (c) 2010 by the Jinja Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from jinja2._compat import imap, text_type, PY2, implements_to_string
+
+
+class TemplateError(Exception):
+    """Baseclass for all template errors."""
+
+    if PY2:
+        def __init__(self, message=None):
+            if message is not None:
+                message = text_type(message).encode('utf-8')
+            Exception.__init__(self, message)
+
+        @property
+        def message(self):
+            if self.args:
+                message = self.args[0]
+                if message is not None:
+                    return message.decode('utf-8', 'replace')
+
+        def __unicode__(self):
+            return self.message or u''
+    else:
+        def __init__(self, message=None):
+            Exception.__init__(self, message)
+
+        @property
+        def message(self):
+            if self.args:
+                message = self.args[0]
+                if message is not None:
+                    return message
+
+
+@implements_to_string
+class TemplateNotFound(IOError, LookupError, TemplateError):
+    """Raised if a template does not exist."""
+
+    # looks weird, but removes the warning descriptor that just
+    # bogusly warns us about message being deprecated
+    message = None
+
+    def __init__(self, name, message=None):
+        IOError.__init__(self)
+        if message is None:
+            message = name
+        self.message = message
+        self.name = name
+        self.templates = [name]
+
+    def __str__(self):
+        return self.message
+
+
+class TemplatesNotFound(TemplateNotFound):
+    """Like :class:`TemplateNotFound` but raised if multiple templates
+    are selected.  This is a subclass of :class:`TemplateNotFound`
+    exception, so just catching the base exception will catch both.
+
+    .. versionadded:: 2.2
+    """
+
+    def __init__(self, names=(), message=None):
+        if message is None:
+            message = u'none of the templates given were found: ' + \
+                      u', '.join(imap(text_type, names))
+        TemplateNotFound.__init__(self, names and names[-1] or None, message)
+        self.templates = list(names)
+
+
+@implements_to_string
+class TemplateSyntaxError(TemplateError):
+    """Raised to tell the user that there is a problem with the template."""
+
+    def __init__(self, message, lineno, name=None, filename=None):
+        TemplateError.__init__(self, message)
+        self.lineno = lineno
+        self.name = name
+        self.filename = filename
+        self.source = None
+
+        # this is set to True if the debug.translate_syntax_error
+        # function translated the syntax error into a new traceback
+        self.translated = False
+
+    def __str__(self):
+        # for translated errors we only return the message
+        if self.translated:
+            return self.message
+
+        # otherwise attach some stuff
+        location = 'line %d' % self.lineno
+        name = self.filename or self.name
+        if name:
+            location = 'File "%s", %s' % (name, location)
+        lines = [self.message, '  ' + location]
+
+        # if the source is set, add the line to the output
+        if self.source is not None:
+            try:
+                line = self.source.splitlines()[self.lineno - 1]
+            except IndexError:
+                line = None
+            if line:
+                lines.append('    ' + line.strip())
+
+        return u'\n'.join(lines)
+
+
+class TemplateAssertionError(TemplateSyntaxError):
+    """Like a template syntax error, but covers cases where something in the
+    template caused an error at compile time that wasn't necessarily caused
+    by a syntax error.  However it's a direct subclass of
+    :exc:`TemplateSyntaxError` and has the same attributes.
+    """
+
+
+class TemplateRuntimeError(TemplateError):
+    """A generic runtime error in the template engine.  Under some situations
+    Jinja may raise this exception.
+    """
+
+
+class UndefinedError(TemplateRuntimeError):
+    """Raised if a template tries to operate on :class:`Undefined`."""
+
+
+class SecurityError(TemplateRuntimeError):
+    """Raised if a template tries to do something insecure if the
+    sandbox is enabled.
+    """
+
+
+class FilterArgumentError(TemplateRuntimeError):
+    """This error is raised if a filter was called with inappropriate
+    arguments
+    """

modules/matlab/test/help.m

+function help()
+%CV.HELP display help information for the OpenCV Toolbox
+%
+%   Calling:
+%   >> cv.help();
+%
+%   is equivalent to calling:
+%   >> help cv;
+%
+%   It displays high-level usage information about the OpenCV toolbox
+%   along with resources to find out more information.
+%
+%   See also: cv.buildInformation
+  help('cv');
+end