added outflow, bgsegm modules; moved matlab from the main repository

modules/bgsegm/CMakeLists.txt

+set(the_description "Background Segmentation Algorithms")
+ocv_define_module(bgsegm opencv_core opencv_imgproc opencv_video opencv_highgui)

modules/bgsegm/include/opencv2/bgsegm.hpp

+/*
+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
+                       (3-clause BSD License)
+
+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:
+
+  * 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.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may 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 copyright holders 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.
+*/
+
+#ifndef __OPENCV_BGSEGM_HPP__
+#define __OPENCV_BGSEGM_HPP__
+
+#include "opencv2/video.hpp"
+
+#ifdef __cplusplus
+
+namespace cv
+{
+namespace bgsegm
+{
+
+/*!
+ Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm
+
+ The class implements the following algorithm:
+ "An improved adaptive background mixture model for real-time tracking with shadow detection"
+ P. KadewTraKuPong and R. Bowden,
+ Proc. 2nd European Workshp on Advanced Video-Based Surveillance Systems, 2001."
+ http://personal.ee.surrey.ac.uk/Personal/R.Bowden/publications/avbs01/avbs01.pdf
+
+*/
+class CV_EXPORTS_W BackgroundSubtractorMOG : public BackgroundSubtractor
+{
+public:
+    CV_WRAP virtual int getHistory() const = 0;
+    CV_WRAP virtual void setHistory(int nframes) = 0;
+
+    CV_WRAP virtual int getNMixtures() const = 0;
+    CV_WRAP virtual void setNMixtures(int nmix) = 0;
+
+    CV_WRAP virtual double getBackgroundRatio() const = 0;
+    CV_WRAP virtual void setBackgroundRatio(double backgroundRatio) = 0;
+
+    CV_WRAP virtual double getNoiseSigma() const = 0;
+    CV_WRAP virtual void setNoiseSigma(double noiseSigma) = 0;
+};
+
+CV_EXPORTS_W Ptr<BackgroundSubtractorMOG>
+    createBackgroundSubtractorMOG(int history=200, int nmixtures=5,
+                                  double backgroundRatio=0.7, double noiseSigma=0);
+                                  
+/**
+ * Background Subtractor module. Takes a series of images and returns a sequence of mask (8UC1)
+ * images of the same size, where 255 indicates Foreground and 0 represents Background.
+ * This class implements an algorithm described in "Visual Tracking of Human Visitors under
+ * Variable-Lighting Conditions for a Responsive Audio Art Installation," A. Godbehere,
+ * A. Matsukawa, K. Goldberg, American Control Conference, Montreal, June 2012.
+ */
+class CV_EXPORTS_W BackgroundSubtractorGMG : public BackgroundSubtractor
+{
+public:
+    CV_WRAP virtual int getMaxFeatures() const = 0;
+    CV_WRAP virtual void setMaxFeatures(int maxFeatures) = 0;
+
+    CV_WRAP virtual double getDefaultLearningRate() const = 0;
+    CV_WRAP virtual void setDefaultLearningRate(double lr) = 0;
+
+    CV_WRAP virtual int getNumFrames() const = 0;
+    CV_WRAP virtual void setNumFrames(int nframes) = 0;
+
+    CV_WRAP virtual int getQuantizationLevels() const = 0;
+    CV_WRAP virtual void setQuantizationLevels(int nlevels) = 0;
+
+    CV_WRAP virtual double getBackgroundPrior() const = 0;
+    CV_WRAP virtual void setBackgroundPrior(double bgprior) = 0;
+
+    CV_WRAP virtual int getSmoothingRadius() const = 0;
+    CV_WRAP virtual void setSmoothingRadius(int radius) = 0;
+
+    CV_WRAP virtual double getDecisionThreshold() const = 0;
+    CV_WRAP virtual void setDecisionThreshold(double thresh) = 0;
+
+    CV_WRAP virtual bool getUpdateBackgroundModel() const = 0;
+    CV_WRAP virtual void setUpdateBackgroundModel(bool update) = 0;
+
+    CV_WRAP virtual double getMinVal() const = 0;
+    CV_WRAP virtual void setMinVal(double val) = 0;
+
+    CV_WRAP virtual double getMaxVal() const = 0;
+    CV_WRAP virtual void setMaxVal(double val) = 0;
+};
+
+CV_EXPORTS_W Ptr<BackgroundSubtractorGMG> createBackgroundSubtractorGMG(int initializationFrames=120,
+                                                                        double decisionThreshold=0.8);                                  
+
+}
+}
+
+#endif
+#endif

modules/bgsegm/samples/bgfg_gmg.cpp

+/*
+ * FGBGTest.cpp
+ *
+ *  Created on: May 7, 2012
+ *      Author: Andrew B. Godbehere
+ */
+
+#include "opencv2/bgsegm.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include <opencv2/core/utility.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace cv::bgsegm;
+
+static void help()
+{
+    std::cout <<
+    "\nA program demonstrating the use and capabilities of a particular BackgroundSubtraction\n"
+    "algorithm described in A. Godbehere, A. Matsukawa, K. Goldberg, \n"
+    "\"Visual Tracking of Human Visitors under Variable-Lighting Conditions for a Responsive\n"
+    "Audio Art Installation\", American Control Conference, 2012, used in an interactive\n"
+    "installation at the Contemporary Jewish Museum in San Francisco, CA from March 31 through\n"
+    "July 31, 2011.\n"
+    "Call:\n"
+    "./BackgroundSubtractorGMG_sample\n"
+    "Using OpenCV version " << CV_VERSION << "\n"<<std::endl;
+}
+
+int main(int argc, char** argv)
+{
+    help();
+
+    setUseOptimized(true);
+    setNumThreads(8);
+
+    Ptr<BackgroundSubtractor> fgbg = createBackgroundSubtractorGMG(20, 0.7);
+    if (!fgbg)
+    {
+        std::cerr << "Failed to create BackgroundSubtractor.GMG Algorithm." << std::endl;
+        return -1;
+    }
+
+    VideoCapture cap;
+    if (argc > 1)
+        cap.open(argv[1]);
+    else
+        cap.open(0);
+
+    if (!cap.isOpened())
+    {
+        std::cerr << "Cannot read video. Try moving video file to sample directory." << std::endl;
+        return -1;
+    }
+
+    Mat frame, fgmask, segm;
+
+    namedWindow("FG Segmentation", WINDOW_NORMAL);
+
+    for (;;)
+    {
+        cap >> frame;
+
+        if (frame.empty())
+            break;
+
+        fgbg->apply(frame, fgmask);
+
+        frame.convertTo(segm, CV_8U, 0.5);
+        add(frame, Scalar(100, 100, 0), segm, fgmask);
+
+        imshow("FG Segmentation", segm);
+
+        int c = waitKey(30);
+        if (c == 'q' || c == 'Q' || (c & 255) == 27)
+            break;
+    }
+
+    return 0;
+}

modules/bgsegm/src/precomp.hpp

+/*
+
+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
+                       (3-clause BSD License)
+
+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:
+
+  * 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.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may 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 copyright holders 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.
+
+*/
+
+#ifndef __OPENCV_BGSEGM_PRECOMP_HPP__
+#define __OPENCV_BGSEGM_PRECOMP_HPP__
+
+#include <opencv2/bgsegm.hpp>
+#include <opencv2/video.hpp>
+#include <opencv2/imgproc.hpp>
+
+#include <algorithm>
+#include <cmath>
+
+#endif

modules/bgsegm/test/test_backgroundsubtractor_gbh.cpp

+/*
+ * BackgroundSubtractorGBH_test.cpp
+ *
+ *  Created on: Jun 14, 2012
+ *      Author: andrewgodbehere
+ */
+
+#include "test_precomp.hpp"
+
+using namespace cv;
+using namespace cv::bgsegm;
+
+class CV_BackgroundSubtractorTest : public cvtest::BaseTest
+{
+public:
+    CV_BackgroundSubtractorTest();
+protected:
+    void run(int);
+};
+
+CV_BackgroundSubtractorTest::CV_BackgroundSubtractorTest()
+{
+}
+
+/**
+ * This test checks the following:
+ * (i) BackgroundSubtractorGMG can operate with matrices of various types and sizes
+ * (ii) Training mode returns empty fgmask
+ * (iii) End of training mode, and anomalous frame yields every pixel detected as FG
+ */
+void CV_BackgroundSubtractorTest::run(int)
+{
+    int code = cvtest::TS::OK;
+    RNG& rng = ts->get_rng();
+    int type = ((unsigned int)rng)%7;  //!< pick a random type, 0 - 6, defined in types_c.h
+    int channels = 1 + ((unsigned int)rng)%4;  //!< random number of channels from 1 to 4.
+    int channelsAndType = CV_MAKETYPE(type,channels);
+    int width = 2 + ((unsigned int)rng)%98; //!< Mat will be 2 to 100 in width and height
+    int height = 2 + ((unsigned int)rng)%98;
+
+    Ptr<BackgroundSubtractorGMG> fgbg = createBackgroundSubtractorGMG();
+    Mat fgmask;
+
+    if (!fgbg)
+        CV_Error(Error::StsError,"Failed to create Algorithm\n");
+
+    /**
+     * Set a few parameters
+     */
+    fgbg->setSmoothingRadius(7);
+    fgbg->setDecisionThreshold(0.7);
+    fgbg->setNumFrames(120);
+
+    /**
+     * Generate bounds for the values in the matrix for each type
+     */
+    double maxd = 0, mind = 0;
+
+    /**
+     * Max value for simulated images picked randomly in upper half of type range
+     * Min value for simulated images picked randomly in lower half of type range
+     */
+    if (type == CV_8U)
+    {
+        uchar half = UCHAR_MAX/2;
+        maxd = (unsigned char)rng.uniform(half+32, UCHAR_MAX);
+        mind = (unsigned char)rng.uniform(0, half-32);
+    }
+    else if (type == CV_8S)
+    {
+        maxd = (char)rng.uniform(32, CHAR_MAX);
+        mind = (char)rng.uniform(CHAR_MIN, -32);
+    }
+    else if (type == CV_16U)
+    {
+        ushort half = USHRT_MAX/2;
+        maxd = (unsigned int)rng.uniform(half+32, USHRT_MAX);
+        mind = (unsigned int)rng.uniform(0, half-32);
+    }
+    else if (type == CV_16S)
+    {
+        maxd = rng.uniform(32, SHRT_MAX);
+        mind = rng.uniform(SHRT_MIN, -32);
+    }
+    else if (type == CV_32S)
+    {
+        maxd = rng.uniform(32, INT_MAX);
+        mind = rng.uniform(INT_MIN, -32);
+    }
+    else if (type == CV_32F)
+    {
+        maxd = rng.uniform(32.0f, FLT_MAX);
+        mind = rng.uniform(-FLT_MAX, -32.0f);
+    }
+    else if (type == CV_64F)
+    {
+        maxd = rng.uniform(32.0, DBL_MAX);
+        mind = rng.uniform(-DBL_MAX, -32.0);
+    }
+
+    fgbg->setMinVal(mind);
+    fgbg->setMaxVal(maxd);
+
+    Mat simImage = Mat::zeros(height, width, channelsAndType);
+    int numLearningFrames = 120;
+    for (int i = 0; i < numLearningFrames; ++i)
+    {
+        /**
+         * Genrate simulated "image" for any type. Values always confined to upper half of range.
+         */
+        rng.fill(simImage, RNG::UNIFORM, (mind + maxd)*0.5, maxd);
+
+        /**
+         * Feed simulated images into background subtractor
+         */
+        fgbg->apply(simImage,fgmask);
+        Mat fullbg = Mat::zeros(simImage.rows, simImage.cols, CV_8U);
+
+        //! fgmask should be entirely background during training
+        code = cvtest::cmpEps2( ts, fgmask, fullbg, 0, false, "The training foreground mask" );
+        if (code < 0)
+            ts->set_failed_test_info( code );
+    }
+    //! generate last image, distinct from training images
+    rng.fill(simImage, RNG::UNIFORM, mind, maxd);
+
+    fgbg->apply(simImage,fgmask);
+    //! now fgmask should be entirely foreground
+    Mat fullfg = 255*Mat::ones(simImage.rows, simImage.cols, CV_8U);
+    code = cvtest::cmpEps2( ts, fgmask, fullfg, 255, false, "The final foreground mask" );
+    if (code < 0)
+    {
+        ts->set_failed_test_info( code );
+    }
+
+}
+
+TEST(VIDEO_BGSUBGMG, accuracy) { CV_BackgroundSubtractorTest test; test.safe_run(); }

modules/bgsegm/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

modules/bgsegm/test/test_precomp.hpp

+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include <iostream>
+#include "opencv2/ts.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/bgsegm.hpp"
+#include "opencv2/imgcodecs.hpp"
+
+#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.
+//
+////////////////////////////////////////////////////////////////////////////////

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()
+
+# -----------------------------------------------------------------------------
+# Compile
+# -----------------------------------------------------------------------------
+# 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
+    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?
+    # TODO: Warnings are currently treated as errors...
+    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.encode('utf-8'))
+
+if __name__ == "__main__":
+    """
+    Usage: python build_info.py --jinja2 /path/to/jinja2/engine
+                                --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('--jinja2')
+    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()
+
+    # add jinja to the path
+    sys.path.append(build.jinja2)
+
+    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.encode('utf-8'))
+
+if __name__ == "__main__":
+    """
+    Usage: python cvmex.py  --jinja2 /path/to/jinja2/engine
+                            --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('--jinja2')
+    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()
+
+    # add jinja to the path
+    sys.path.append(cv.jinja2)
+
+    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
+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+escapn.join(escapn.join(line) for line in wlines)+escape_last

modules/matlab/generator/gen_matlab.py

+#!/usr/bin/env python
+import sys, re, os, time
+from string import Template
+from parse_tree import ParseTree, todict, constants
+from filters import *
+
+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.
+        """
+        # dynamically import the parsers
+        from jinja2 import Environment, FileSystemLoader
+        import hdr_parser
+        import rst_parser
+
+        # parse each of the files and store in a dictionary
+        # as a separate "namespace"
+        parser = hdr_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.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)
+                with open(output_source_dir+'/'+method.name+'.cpp', 'wb') as f:
+                    f.write(populated.encode('utf-8'))
+                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.encode('utf-8'))
+            # 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.encode('utf-8'))
+                # matlab classdef
+                populated = tclassm.render(clss=clss, time=time)
+                with open(output_class_dir+'/'+clss.name+'.m', 'wb') as f:
+                    f.write(populated.encode('utf-8'))
+
+        # 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.encode('utf-8'))
+
+
+if __name__ == "__main__":
+    """
+    Usage: python gen_matlab.py --jinja2 /path/to/jinja2/engine
+                                --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:
+    --jinja2       the path to the Jinja2 templating engine
+                   e.g. ${CMAKE_SOURCE_DIR}/3rdparty
+    --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
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('--jinja2')
+    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.jinja2)
+    sys.path.append(args.hdrparser)
+    sys.path.append(args.rstparser)
+
+    # create the generator
+    mwg = MatlabWrapperGenerator()
+    mwg.gen(args.moduleroot, args.modules, args.extra, args.outdir)

modules/matlab/generator/templates/functional.cpp

+/*
+ * compose
+ * compose a function call
+ * This macro takes as input a Method object and composes
+ * a function call by inspecting the types and argument names
+ */
+{% macro compose(fun) %}
+  {# ----------- Return type ------------- #}
+  {%- if not fun.rtp|void and not fun.constructor -%} retval = {% endif -%}
+  {%- if fun.constructor -%}{{fun.clss}} obj = {% endif -%}
+  {%- if fun.clss and not fun.constructor -%}inst.{%- else -%} cv:: {%- endif -%}
+  {{fun.name}}(
+  {#- ----------- Required ------------- -#}
+  {%- for arg in fun.req -%}
+    {%- if arg.ref == '*' -%}&{%- endif -%}
+    {{arg.name}}
+    {%- if not loop.last %}, {% endif %}
+  {% endfor %}
+  {#- ----------- Optional ------------- -#}
+  {% if fun.req and fun.opt %}, {% endif %}
+  {%- for opt in fun.opt -%}
+    {%- if opt.ref == '*' -%}&{%- endif -%}
+    {{opt.name}}
+    {%- if not loop.last -%}, {% endif %}
+  {%- endfor -%}
+  );
+{%- endmacro %}
+
+
+/*
+ * composeMatlab
+ * compose a Matlab function call
+ * This macro takes as input a Method object and composes
+ * a Matlab function call by inspecting the types and argument names
+ */
+{% macro composeMatlab(fun) %}
+  {# ----------- Return type ------------- #}
+  {%- if fun|noutputs > 1 -%}[{% endif -%}
+  {%- if not fun.rtp|void -%}LVALUE{% endif -%}
+  {%- if not fun.rtp|void and fun|noutputs > 1 -%},{% endif -%}
+  {# ------------- Outputs ------------- -#}
+  {%- for arg in fun.req|outputs + fun.opt|outputs -%}
+    {{arg.name}}
+    {%- if arg.I -%}_out{%- endif -%}
+    {%- if not loop.last %}, {% endif %}
+  {% endfor %}
+  {%- if fun|noutputs > 1 -%}]{% endif -%}
+  {%- if fun|noutputs %} = {% endif -%}
+  cv.{{fun.name}}(
+  {#- ------------ Inputs -------------- -#}
+  {%- for arg in fun.req|inputs + fun.opt|inputs -%}
+    {{arg.name}}
+    {%- if arg.O -%}_in{%- endif -%}
+    {%- if not loop.last %}, {% endif -%}
+  {% endfor -%}
+  );
+{%- endmacro %}
+
+
+/*
+ * composeVariant
+ * compose a variant call for the ArgumentParser
+ */
+{% macro composeVariant(fun) %}
+addVariant("{{ fun.name }}", {{ fun.req|inputs|length }}, {{ fun.opt|inputs|length }}
+{%- if fun.opt|inputs|length %}, {% endif -%}
+{%- for arg in fun.opt|inputs -%}
+  "{{arg.name}}"
+  {%- if not loop.last %}, {% endif -%}
+{% endfor -%}
+)
+{%- endmacro %}
+
+
+/*
+ * composeWithExceptionHandler
+ * compose a function call wrapped in exception traps
+ * This macro takes an input a Method object and composes a function
+ * call through the compose() macro, then wraps the return in traps
+ * for cv::Exceptions, std::exceptions, and all generic exceptions
+ * and returns a useful error message to the Matlab interpreter
+ */
+{%- macro composeWithExceptionHandler(fun) -%}
+  // call the opencv function
+  // [out =] namespace.fun(src1, ..., srcn, dst1, ..., dstn, opt1, ..., optn);
+  try {
+    {{ compose(fun) }}
+  } catch(cv::Exception& e) {
+    error(std::string("cv::exception caught: ").append(e.what()).c_str());
+  } catch(std::exception& e) {
+    error(std::string("std::exception caught: ").append(e.what()).c_str());
+  } catch(...) {
+    error("Uncaught exception occurred in {{fun.name}}");
+  }
+{%- endmacro %}
+
+
+/*
+ * handleInputs
+ * unpack input arguments from the Bridge
+ * Given an input Bridge object, this unpacks the object from the Bridge and
+ * casts them into the correct type
+ */
+{%- macro handleInputs(fun) %}
+
+  {% if fun|ninputs or (fun|noutputs and not fun.constructor) %}
+  // unpack the arguments
+  {# ----------- Inputs ------------- #}
+  {% for arg in fun.req|inputs %}
+  {{arg.tp}} {{arg.name}} = inputs[{{ loop.index0 }}].to{{arg.tp|toUpperCamelCase}}();
+  {% endfor %}
+  {% for opt in fun.opt|inputs %}
+  {{opt.tp}} {{opt.name}} = inputs[{{loop.index0 + fun.req|inputs|length}}].empty() ? ({{opt.tp}}) {% if opt.ref == '*' -%} {{opt.tp}}() {%- else -%} {{opt.default}} {%- endif %} : inputs[{{loop.index0 + fun.req|inputs|length}}].to{{opt.tp|toUpperCamelCase}}();
+  {% endfor %}
+  {# ----------- Outputs ------------ #}
+  {% for arg in fun.req|only|outputs %}
+  {{arg.tp}} {{arg.name}};
+  {% endfor %}
+  {% for opt in fun.opt|only|outputs %}
+  {{opt.tp}} {{opt.name}};
+  {% endfor %}
+  {% if not fun.rtp|void and not fun.constructor %}
+  {{fun.rtp}} retval;
+  {% endif %}
+  {% endif %}
+
+{%- endmacro %}
+
+/*
+ * handleOutputs
+ * pack outputs into the bridge
+ * Given a set of outputs, this methods assigns them into the bridge for
+ * return to the calling method
+ */
+{%- macro handleOutputs(fun) %}
+
+  {% if fun|noutputs %}
+  // assign the outputs into the bridge
+  {% if not fun.rtp|void and not fun.constructor %}
+  outputs[0] = retval;
+  {% endif %}
+  {% for arg in fun.req|outputs %}
+  outputs[{{loop.index0 + fun.rtp|void|not}}] = {{arg.name}};
+  {% endfor %}
+  {% for opt in fun.opt|outputs %}
+  outputs[{{loop.index0 + fun.rtp|void|not + fun.req|outputs|length}}] = {{opt.name}};
+  {% endfor %}
+  {% endif %}
+{%- endmacro %}

modules/matlab/generator/templates/template_build_info.m

+function buildInformation()
+%CV.BUILDINFORMATION display OpenCV Toolbox build information
+%
+%   Call CV.BUILDINFORMATION() to get a printout of diagonstic information
+%   pertaining to your particular build of the OpenCV Toolbox. If you ever
+%   run into issues with the Toolbox, it is useful to submit this
+%   information alongside a bug report to the OpenCV team.
+%
+%   Copyright {{ time.strftime("%Y", time.localtime()) }} The OpenCV Foundation
+%
+info = {
+'  ------------------------------------------------------------------------'
+'                              <strong>OpenCV Toolbox</strong>'
+'                     Build and diagnostic information'
+'  ------------------------------------------------------------------------'
+''
+'  <strong>Platform</strong>'
+'  OS:            {{ build.os }}'
+'  Architecture:  {{ build.arch[0] }}-bit {{ build.arch[1] }}'
+'  Compiler:      {{ build.compiler | csv(' ') }}'
+''
+'  <strong>Matlab</strong>'
+['  Version:       ' version()]
+['  Mex extension: ' mexext()]
+'  Architecture:  {{ build.mex_arch }}'
+'  Mex path:      {{ build.mex_script }}'
+'  Mex flags:     {{ build.mex_opts | csv(' ') }}'
+'  CXX flags:     {{ build.cxx_flags | csv(' ') | stripExtraSpaces | wordwrap(60, True, '\'\n\'                 ') }}'
+''
+'  <strong>OpenCV</strong>'
+'  Version:       {{ build.opencv_version }}'
+'  Commit:        {{ build.commit }}'
+'  Configuration: {{ build.configuration }}'
+'  Modules:       {{ build.modules | csv | wordwrap(60, True, '\'\n\'                 ') }}'
+''
+};
+
+info = cellfun(@(x) [x '\n'], info, 'UniformOutput', false);
+info = horzcat(info{:});
+fprintf(info);
+end

modules/matlab/generator/templates/template_class_base.cpp

+{% import 'functional.cpp' as functional %}
+/*
+ * file:   {{clss.name}}Bridge.cpp
+ * author: A trusty code generator
+ * date:   {{time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())}}
+ *
+ * This file was autogenerated, do not modify.
+ * See LICENSE for full modification and redistribution details.
+ * Copyright {{time.strftime("%Y", time.localtime())}} The OpenCV Foundation
+ */
+#include <mex.h>
+#include <vector>
+#include <string>
+#include <opencv2/matlab/map.hpp>
+#include <opencv2/matlab/bridge.hpp>
+#include <opencv2/core.hpp>
+using namespace cv;
+using namespace matlab;
+using namespace bridge;
+
+namespace {
+
+typedef std::vector<Bridge> (*)({{clss.name}}&, const std::vector<Bridge>&) MethodSignature;
+
+{% for function in clss.methods %}
+
+{% if function.constructor %}
+// wrapper for {{function.name}}() constructor
+{{ function.clss }} {{function.name}}(const std::vector<Bridge>& inputs) {
+  {{ functional.handleInputs(function) }}
+  {{ functional.compose(function) }}
+  return obj;
+}
+{% else %}
+// wrapper for {{function.name}}() method
+std::vector<Bridge> {{function.name}}({{clss.name}}& inst, const std::vector<Bridge>& inputs) {
+  std::vector<Bridge> outputs{% if function|noutputs %}({{function|noutputs}}){% endif %};
+  {{ functional.handleInputs(function) }}
+  {{ functional.composeWithExceptionHandler(function) }}
+  {{ functional.handleOutputs(function) }}
+  return outputs;
+}
+{% endif %}
+{% endfor %}
+
+Map<std::string, MethodSignature> createMethodMap() {
+  Map<std::string, MethodSignature> m;
+  {% for function in clss.methods %}
+  m["{{function.name}}"] = &{{function.name}};
+  {% endfor %}
+
+  return m;
+}
+static const Map<std::string, MethodSignature> methods = createMethodMap();
+
+// map of created {{clss.name}} instances. Don't trust the user to keep them safe...
+static Map<void *, {{clss.name}}> instances;
+
+/*
+ * {{ clss.name }}
+ * Gateway routine
+ *   nlhs - number of return arguments
+ *   plhs - pointers to return arguments
+ *   nrhs - number of input arguments
+ *   prhs - pointers to input arguments
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+                 int nrhs, const mxArray* prhs[]) {
+
+  // parse the inputs
+  Bridge method_name(prhs[0]);
+
+  Bridge handle(prhs[1]);
+  std::vector<Bridge> brhs(prhs+2, prhs+nrhs);
+
+  // retrieve the instance of interest
+  try {
+    {{clss.name}}& inst = instances.at(handle.address());
+  } catch (const std::out_of_range& e) {
+    mexErrMsgTxt("Invalid object instance provided");
+  }
+
+  // invoke the correct method on the data
+  try {
+    std::vector<Bridge> blhs = (*methods.at(method_name))(inst, brhs);
+  } catch (const std::out_of_range& e) {
+    mexErrMsgTxt("Unknown method specified");
+  }
+
+  {% block postfun %}
+  {% endblock %}
+
+  {% block cleanup %}
+  {% endblock %}
+
+}
+
+} // end namespace

modules/matlab/generator/templates/template_class_base.m

+% {{clss.name | upper}}
+% Matlab handle class for OpenCV object classes
+%
+% This file was autogenerated, do not modify.
+% See LICENSE for full modification and redistribution details.
+% Copyright {{time.strftime("%Y", time.localtime())}} The OpenCV Foundation
+classdef {{clss.name}} < handle
+  properties (SetAccess = private, Hidden = true)
+    ptr_ = 0; % handle to the underlying c++ clss instance
+  end
+
+  methods
+    % constructor
+    function this = {{clss.name}}(varargin)
+      this.ptr_ = {{clss.name}}Bridge('new', varargin{:});
+    end
+
+    % destructor
+    function delete(this)
+      {{clss.name}}Bridge(this.ptr_, 'delete');
+    end
+
+    {% for function in clss.functions %}
+    % {{function.__str__()}}
+    function varargout = {{function.name}}(this, varargin)
+      [varargout{1:nargout}] = {{clss.name}}Bridge('{{function.name}}', this.ptr_, varargin{:});
+    end
+
+    {% endfor %}
+  end
+end

modules/matlab/generator/templates/template_cvmex_base.m

+function mex(varargin)
+%CV.MEX compile MEX-function with OpenCV linkages
+%
+%   Usage:
+%       CV.MEX [options ...] file [file file ...]
+%
+%   Description:
+%       CV.MEX compiles one or more C/C++ source files into a shared-library
+%       called a mex-file. This function is equivalent to the builtin MEX
+%       routine, with the notable exception that it automatically resolves
+%       OpenCV includes, and links in the OpenCV libraries where appropriate.
+%       It also forwards the flags used to build OpenCV, so architecture-
+%       specific optimizations can be used.
+%
+%       CV.MEX is designed to be used in situations where the source(s) you
+%       are compiling contain OpenCV definitions. In such cases, it streamlines
+%       the finding and including of appropriate OpenCV libraries.
+%
+%   See also: mex
+%
+%   Copyright {{ time.strftime("%Y", time.localtime()) }} The OpenCV Foundation
+%
+
+  % forward the OpenCV build flags (C++ only)
+  EXTRA_FLAGS  = ['"CXXFLAGS="\$CXXFLAGS '...
+                  '{{ cv.flags | trim | wordwrap(60, false, '\'...\n                  \'') }}""'];
+
+  % add the OpenCV include dirs
+  INCLUDE_DIRS = {{ cv.include_dirs | split | cellarray | wordwrap(60, false, '...\n                  ') }};
+
+  % add the lib dir (singular in both build tree and install tree)
+  LIB_DIR      = '{{ cv.lib_dir }}';
+
+  % add the OpenCV libs. Only the used libs will actually be linked
+  LIBS         = {{ cv.libs | split | cellarray | wordwrap(60, false, '...\n                  ') }};
+
+  % add the mex opts (usually at least -largeArrayDims)
+  OPTS         = {{ cv.opts | split | cellarray | wordwrap(60, false, '...\n                  ') }};
+
+  % merge all of the default options (EXTRA_FLAGS, LIBS, etc) and the options
+  % and files passed by the user (varargin) into a single cell array
+  merged       = [ {EXTRA_FLAGS}, INCLUDE_DIRS, {LIB_DIR}, LIBS, OPTS, varargin ];
+
+  % expand the merged argument list into the builtin mex utility
+  mex(merged{:});
+end

modules/matlab/generator/templates/template_doc_base.m

+{% import 'functional.cpp' as functional %}
+{{ ('CV.' + fun.name | upper + ' ' + doc.brief | stripTags) | comment(75, '%') | matlabURL }}
+%
+%   {{ functional.composeMatlab(fun) | upper }}
+{% if doc.long %}
+{{ doc.long | stripTags | qualify(fun.name) | comment(75, '%   ') | matlabURL }}
+{% endif %}
+%
+{# ----------------------- Returns --------------------- #}
+{% if fun.rtp|void|not or fun.req|outputs|length or fun.opt|outputs|length %}
+%   Returns:
+{% if fun.rtp|void|not %}
+%      LVALUE
+{% endif %}
+{% for arg in fun.req|outputs + fun.opt|outputs %}
+{% set uname = arg.name | upper + ('_OUT' if arg.I else '') %}
+{% if arg.name in doc.params %}
+{{ (uname + ' ' + doc.params[arg.name]) | stripTags | comment(75, '%     ') }}
+{% else %}
+{{ uname }}
+{% endif %}
+{% endfor %}
+%
+{% endif %}
+{# ----------------- Required Inputs ------------------- #}
+{% if fun.req|inputs|length %}
+%   Required Inputs:
+{% for arg in fun.req|inputs %}
+{% set uname = arg.name | upper + ('_IN' if arg.O else '') %}
+{% if arg.name in doc.params %}
+{{ (uname + ' ' + doc.params[arg.name]) | stripTags | comment(75, '%     ') }}
+{% else %}
+{% endif %}
+{% endfor %}
+%
+{% endif %}
+{# ------------------ Optional Inputs ------------------- #}
+{% if fun.opt|inputs|length %}
+%   Optional Inputs:
+{% for arg in fun.opt|inputs %}
+{% set uname = arg.name | upper + ('_IN' if arg.O else '') + ' (default: ' + arg.default + ')' %}
+{% if arg.name in doc.params %}
+{{ (uname + ' ' + doc.params[arg.name]) | stripTags | comment(75, '%     ') }}
+{% else %}
+{{ uname }}
+{% endif %}
+{% endfor %}
+%
+{% endif %}
+{# ---------------------- See also --------------------- #}
+{% if 'seealso' in doc %}
+%   See also: {% for item in doc['seealso'] %}
+cv.{{ item }}{% if not loop.last %}, {% endif %}
+{% endfor %}
+
+%
+{% endif %}
+{# ----------------------- Online ---------------------- #}
+{% set url = 'http://docs.opencv.org/modules/' + doc.module  + '/doc/' + (doc.file|filename) + '.html#' + (fun.name|slugify) %}
+%   Online docs: {{ url | matlabURL }}
+%   Copyright {{ time.strftime("%Y", time.localtime()) }} The OpenCV Foundation
+%

modules/matlab/generator/templates/template_function_base.cpp

+{% import 'functional.cpp' as functional %}
+/*
+ * file:   {{fun.name}}.cpp
+ * author: A trusty code generator
+ * date:   {{time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())}}
+ *
+ * This file was autogenerated, do not modify.
+ * See LICENSE for full modification and redistribution details.
+ * Copyright {{time.strftime("%Y", time.localtime())}} The OpenCV Foundation
+ */
+#include <string>
+#include <vector>
+#include <cassert>
+#include <exception>
+#include <opencv2/matlab/bridge.hpp>
+#include <opencv2/{{includes}}.hpp>
+using namespace cv;
+using namespace matlab;
+using namespace bridge;
+
+/*
+ * {{ fun.name }}
+ * {{ fun }}
+ * Gateway routine
+ *   nlhs - number of return arguments
+ *   plhs - pointers to return arguments
+ *   nrhs - number of input arguments
+ *   prhs - pointers to input arguments
+ */
+void mexFunction(int nlhs, mxArray*{% if fun|noutputs %} plhs[]{% else %}*{% endif %},
+                 int nrhs, const mxArray*{% if fun|ninputs %} prhs[]{% else %}*{% endif %}) {
+
+  {% if fun|ninputs %}
+  // parse the inputs
+  ArgumentParser parser("{{fun.name}}");
+  parser.{{ functional.composeVariant(fun) }};
+  MxArrayVector sorted = parser.parse(MxArrayVector(prhs, prhs+nrhs));
+  {% endif %}
+
+  {% if fun|ninputs or fun|noutputs %}
+  // setup
+  {% if fun|ninputs %}
+  BridgeVector inputs(sorted.begin(), sorted.end());
+  {% endif -%}
+  {%- if fun|noutputs %}
+  BridgeVector outputs({{fun|noutputs}});
+  {% endif %}
+  {% endif %}
+
+  {{ functional.handleInputs(fun) }}
+  {{ functional.composeWithExceptionHandler(fun) }}
+  {{ functional.handleOutputs(fun) }}
+
+  {% if fun|noutputs %}
+  // push the outputs back to matlab
+  for (size_t n = 0; n < static_cast<size_t>(std::max(nlhs,1)); ++n) {
+    plhs[n] = outputs[n].toMxArray().releaseOwnership();
+  }
+  {% endif %}
+}

modules/matlab/generator/templates/template_map_base.m

+% ------------------------------------------------------------------------
+%                             <strong>OpenCV Toolbox</strong>
+%                  Matlab bindings for the OpenCV library
+% ------------------------------------------------------------------------
+%
+% The OpenCV Toolbox allows you to make calls to native OpenCV methods
+% and classes directly from within Matlab.
+%
+% <strong>PATHS</strong>
+% To call OpenCV methods from anywhere in your workspace, add the
+% directory containing this file to the path:
+%
+%     addpath(fileparts(which('cv')));
+%
+% The OpenCV Toolbox contains two important locations:
+%     cv.m - This file, containing OpenCV enums
+%     +cv/ - The directory containing the OpenCV methods and classes
+%
+% <strong>CALLING SYNTAX</strong>
+% To call an OpenCV method, class or enum, it must be prefixed with the
+% 'cv' qualifier. For example:
+%
+%     % perform a Fourier transform
+%     Xf = cv.dft(X, cv.DFT_COMPLEX_OUTPUT);
+%
+%     % create a VideoCapture object, and open a file
+%     camera = cv.VideoCapture();
+%     camera.open('/path/to/file');
+%
+% You can specify optional arguments by name, similar to how python
+% and many builtin Matlab functions work. For example, the cv.dft
+% method used above has an optional 'nonzeroRows' argument. If
+% you want to specify that, but keep the default 'flags' behaviour,
+% simply call the method as:
+%
+%     Xf = cv.dft(X, 'nonzeroRows', 7);
+%
+% <strong>HELP</strong>
+% Each method has its own help file containing information about the
+% arguments, return values, and what operation the method performs.
+% You can access this help information by typing:
+%
+%     help cv.methodName
+%
+% The full list of methods can be found by inspecting the +cv/
+% directory. Note that the methods available to you will depend
+% on which modules you configured OpenCV to build.
+%
+% <strong>DIAGNOSTICS</strong>
+% If you are having problems with the OpenCV Toolbox and need to send a
+% bug report to the OpenCV team, you can get a printout of diagnostic
+% information to submit along with your report by typing:
+%
+%     <a href="matlab: cv.buildInformation()">cv.buildInformation();</a>
+%
+% <strong>OTHER RESOURCES</strong>
+% OpenCV documentation online: <a href="matlab: web('http://docs.opencv.org', '-browser')">http://docs.opencv.org</a>
+% OpenCV issue tracker: <a href="matlab: web('http://code.opencv.org', '-browser')">http://code.opencv.org</a>
+% OpenCV Q&A: <a href="matlab: web('http://answers.opencv.org', '-browser')">http://answers.opencv.org</a>
+%
+% See also: cv.help, <a href="matlab: cv.buildInformation()">cv.buildInformation</a>
+%
+% Copyright {{ time.strftime("%Y", time.localtime()) }} The OpenCV Foundation
+%
+classdef cv
+    properties (Constant = true)
+    {% for key, val in constants.items() %}
+        {{key}} = {{val|formatMatlabConstant(constants)}};
+    {% endfor %}
+    end
+end

modules/matlab/include/opencv2/matlab/map.hpp

+////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef OPENCV_MAP_HPP_
+#define OPENCV_MAP_HPP_
+
+namespace matlab {
+#if __cplusplus >= 201103L
+
+ // If we have C++11 support, we just want to use unordered_map
+#include <unordered_map>
+template <typename KeyType, typename ValueType>
+using Map = std::unordered_map<KeyType, ValueType>;
+
+#else
+
+// If we don't have C++11 support, we wrap another map implementation
+// in the same public API as unordered_map
+#include <map>
+#include <stdexcept>
+
+template <typename KeyType, typename ValueType>
+class Map {
+private:
+  std::map<KeyType, ValueType> map_;
+public:
+  // map[key] = val;
+  ValueType& operator[] (const KeyType& k) {
+    return map_[k];
+  }
+
+  // map.at(key) = val (throws)
+  ValueType& at(const KeyType& k) {
+    typename std::map<KeyType, ValueType>::iterator it;
+    it = map_.find(k);
+    if (it == map_.end()) throw std::out_of_range("Key not found");
+    return *it;
+  }
+
+  // val = map.at(key)  (throws, const)
+  const ValueType& at(const KeyType& k) const {
+    typename std::map<KeyType, ValueType>::const_iterator it;
+    it = map_.find(k);
+    if (it == map_.end()) throw std::out_of_range("Key not found");
+    return *it;
+  }
+};
+
+} // namespace matlab
+
+#endif
+#endif

modules/matlab/include/opencv2/matlab/transpose.hpp

+////////////////////////////////////////////////////////////////////////////////
+//
+//  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.
+//
+////////////////////////////////////////////////////////////////////////////////
+#ifndef OPENCV_TRANSPOSE_HPP_
+#define OPENCV_TRANSPOSE_HPP_
+
+template <typename InputScalar, typename OutputScalar>
+void transposeBlock(const size_t M, const size_t N, const InputScalar* src, size_t lda, OutputScalar* dst, size_t ldb) {
+  InputScalar cache[16];
+  // copy the source into the cache contiguously
+  for (size_t n = 0; n < N; ++n)
+    for (size_t m = 0; m < M; ++m)
+      cache[m+n*4] = src[m+n*lda];
+  // copy the destination out of the cache contiguously
+  for (size_t m = 0; m < M; ++m)
+    for (size_t n = 0; n < N; ++n)
+      dst[n+m*ldb] = cache[m+n*4];
+}
+
+template <typename InputScalar, typename OutputScalar>
+void transpose4x4(const InputScalar* src, size_t lda, OutputScalar* dst, size_t ldb) {
+  InputScalar cache[16];
+  // copy the source into the cache contiguously
+  cache[0] = src[0];  cache[1] = src[1];  cache[2] = src[2];  cache[3] = src[3];  src+=lda;
+  cache[4] = src[0];  cache[5] = src[1];  cache[6] = src[2];  cache[7] = src[3];  src+=lda;
+  cache[8] = src[0];  cache[9] = src[1];  cache[10] = src[2]; cache[11] = src[3]; src+=lda;
+  cache[12] = src[0]; cache[13] = src[1]; cache[14] = src[2]; cache[15] = src[3]; src+=lda;
+  // copy the destination out of the contiguously
+  dst[0] = cache[0];  dst[1] = cache[4];  dst[2] = cache[8];   dst[3] = cache[12]; dst+=ldb;
+  dst[0] = cache[1];  dst[1] = cache[5];  dst[2] = cache[9];   dst[3] = cache[13]; dst+=ldb;
+  dst[0] = cache[2];  dst[1] = cache[6];  dst[2] = cache[10];  dst[3] = cache[14]; dst+=ldb;
+  dst[0] = cache[3];  dst[1] = cache[7];  dst[2] = cache[11];  dst[3] = cache[15]; dst+=ldb;
+}
+
+
+/*
+ * Vanilla copy, transpose and cast
+ */
+template <typename InputScalar, typename OutputScalar>
+void gemt(const char major, const size_t M, const size_t N, const InputScalar* a, size_t lda, OutputScalar* b, size_t ldb) {
+
+  // 1x1 transpose is just copy
+  if (M == 1 && N == 1) { *b = *a; return; }
+
+  // get the interior 4x4 blocks, and the extra skirting
+  const size_t Fblock = (major == 'R') ? N/4 : M/4;
+  const size_t Frem   = (major == 'R') ? N%4 : M%4;
+  const size_t Sblock = (major == 'R') ? M/4 : N/4;
+  const size_t Srem   = (major == 'R') ? M%4 : N%4;
+
+  // if less than 4x4, invoke the block transpose immediately
+  if (M < 4 && N < 4) { transposeBlock(Frem, Srem, a, lda, b, ldb); return; }
+
+  // transpose 4x4 blocks
+  const InputScalar* aptr = a;
+  OutputScalar* bptr = b;
+  for (size_t second = 0; second < Sblock; ++second) {
+    aptr = a + second*lda;
+    bptr = b + second;
+    for (size_t first = 0; first < Fblock; ++first) {
+      transposeBlock(4, 4, aptr, lda, bptr, ldb);
+      //transpose4x4(aptr, lda, bptr, ldb);
+      aptr+=4;
+      bptr+=4*ldb;
+    }
+    // transpose trailing blocks on primary dimension
+    transposeBlock(Frem, 4, aptr, lda, bptr, ldb);
+  }
+  // transpose trailing blocks on secondary dimension
+  aptr = a + 4*Sblock*lda;
+  bptr = b + 4*Sblock;
+  for (size_t first = 0; first < Fblock; ++first) {
+    transposeBlock(4, Srem, aptr, lda, bptr, ldb);
+    aptr+=4;
+    bptr+=4*ldb;
+  }
+  // transpose bottom right-hand corner
+  transposeBlock(Frem, Srem, aptr, lda, bptr, ldb);
+}
+
+#ifdef __SSE2__
+/*
+ * SSE2 supported fast copy, transpose and cast
+ */
+#include <emmintrin.h>
+
+template <>
+void transpose4x4<float, float>(const float* src, size_t lda, float* dst, size_t ldb) {
+  __m128 row0, row1, row2, row3;
+  row0 = _mm_loadu_ps(src);
+  row1 = _mm_loadu_ps(src+lda);
+  row2 = _mm_loadu_ps(src+2*lda);
+  row3 = _mm_loadu_ps(src+3*lda);
+  _MM_TRANSPOSE4_PS(row0, row1, row2, row3);
+  _mm_storeu_ps(dst, row0);
+  _mm_storeu_ps(dst+ldb, row1);
+  _mm_storeu_ps(dst+2*ldb, row2);
+  _mm_storeu_ps(dst+3*ldb, row3);
+}
+
+#endif
+#endif

modules/matlab/test/CMakeLists.txt

+set(TEST_PROXY ${CMAKE_CURRENT_BINARY_DIR}/test.proxy)
+file(REMOVE ${TEST_PROXY})
+
+# generate
+# call the python executable to generate the Matlab gateways
+add_custom_command(
+    OUTPUT ${TEST_PROXY}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/OpenCVTest.m ${CMAKE_CURRENT_BINARY_DIR}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/testsuite.m ${CMAKE_CURRENT_BINARY_DIR}
+    COMMAND ${CMAKE_COMMAND} -E touch ${TEST_PROXY}
+    COMMENT "Building Matlab tests"
+)
+
+# targets
+# opencv_matlab_sources --> opencv_matlab
+add_custom_target(opencv_test_matlab ALL DEPENDS ${TEST_PROXY})
+add_dependencies(opencv_test_matlab ${the_module})
+
+# run the matlab test suite
+add_test(opencv_test_matlab
+    COMMAND ${MATLAB_BIN} "-nodisplay" "-r" "testsuite.m"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+)

modules/matlab/test/OpenCVTest.m

+% Matlab binding test cases
+% Uses Matlab's builtin testing framework
+classdef OpenCVTest < matlab.unittest.TestCase
+
+  methods(Test)
+
+    % -------------------------------------------------------------------------
+    % EXCEPTIONS
+    % Check that errors and exceptions are thrown correctly
+    % -------------------------------------------------------------------------
+
+    % check that std exception is thrown
+    function stdException(testcase)
+      try
+        std_exception();
+        testcase.verifyFail();
+      catch
+        % TODO: Catch more specific exception
+        testcase.verifyTrue(true);
+      end
+    end
+
+    % check that OpenCV exceptions are correctly caught
+    function cvException(testcase)
+      try
+        cv_exception();
+        testcase.verifyFail();
+      catch
+        % TODO: Catch more specific exception
+        testcase.verifyTrue(true);
+      end
+    end
+
+    % check that all exceptions are caught
+    function allException(testcase)
+      try
+        exception();
+        testcase.verifyFail();
+      catch
+        % TODO: Catch more specific exception
+        testcase.verifyTrue(true);
+      end
+    end
+
+    % -------------------------------------------------------------------------
+    % SIZES AND FILLS
+    % Check that matrices are correctly filled and resized
+    % -------------------------------------------------------------------------
+
+    % check that a matrix is correctly filled with random numbers
+    function randomFill(testcase)
+      sz = [7 11];
+      mat = zeros(sz);
+      mat = cv.randn(mat, 0, 1);
+      testcase.verifyEqual(size(mat), sz, 'Matrix should not change size');
+      testcase.verifyNotEqual(mat, zeros(sz), 'Matrix should be nonzero');
+    end
+
+    function transpose(testcase)
+      m = randn(19, 81);
+      mt1 = transpose(m);
+      mt2 = cv.transpose(m);
+      testcase.verifyEqual(size(mt1), size(mt2), 'Matrix transposed to incorrect dimensionality');
+      testcase.verifyLessThan(norm(mt1 - mt2), 1e-8, 'Too much precision lost in tranposition');
+    end
+
+    % multiple return
+    function multipleReturn(testcase)
+      A = randn(10);
+      A = A'*A;
+      [V1, D1] = eig(A); D1 = diag(D1);
+      [~, D2, V2] = cv.eigen(A);
+      testcase.verifyLessThan(norm(V1 - V2), 1e-6, 'Too much precision lost in eigenvectors');
+      testcase.verifyLessThan(norm(D1 - D2), 1e-6, 'Too much precision lost in eigenvalues');
+    end
+
+    % complex output from SVD
+    function complexOutputSVD(testcase)
+      A = randn(10);
+      [V1, D1] = eig(A);
+      [~, D2, V2] = cv.eigen(A);
+      testcase.verifyTrue(~isreal(V2) && size(V2,3) == 1, 'Output should be complex');
+      testcase.verifyLessThan(norm(V1 - V2), 1e-6, 'Too much precision lost in eigenvectors');
+    end
+
+    % complex output from Fourier Transform
+    function complexOutputFFT(testcase)
+      A = randn(10);
+      F1 = fft2(A);
+      F2 = cv.dft(A, cv.DFT_COMPLEX_OUTPUT);
+      testcase.verifyTrue(~isreal(F2) && size(F2,3) == 1, 'Output should be complex');
+      testcase.verifyLessThan(norm(F1 - F2), 1e-6, 'Too much precision lost in eigenvectors');
+    end
+
+    % -------------------------------------------------------------------------
+    % TYPE CASTS
+    % Check that types are correctly cast
+    % -------------------------------------------------------------------------
+
+    % -------------------------------------------------------------------------
+    % PRECISION
+    % Check that basic operations are performed with sufficient precision
+    % -------------------------------------------------------------------------
+
+    % check that summing elements is within reasonable precision
+    function sumElements(testcase)
+      a = randn(5000);
+      b = sum(a(:));
+      c = cv.sum(a);
+      testcase.verifyLessThan(norm(b - c), 1e-8, 'Matrix reduction with insufficient precision');
+    end
+
+
+    % check that adding two matrices is within reasonable precision
+    function addPrecision(testcase)
+      a = randn(50);
+      b = randn(50);
+      c = a+b;
+      d = cv.add(a, b);
+      testcase.verifyLessThan(norm(c - d), 1e-8, 'Matrices are added with insufficient precision');
+    end
+
+    % check that performing gemm is within reasonable precision
+    function gemmPrecision(testcase)
+      a = randn(10, 50);
+      b = randn(50, 10);
+      c = randn(10, 10);
+      alpha = 2.71828;
+      gamma = 1.61803;
+      d = alpha*a*b + gamma*c;
+      e = cv.gemm(a, b, alpha, c, gamma);
+      testcase.verifyLessThan(norm(d - e), 1e-8, 'Matrices are multiplied with insufficient precision');
+    end
+
+
+    % -------------------------------------------------------------------------
+    % MISCELLANEOUS
+    % Miscellaneous tests
+    % -------------------------------------------------------------------------
+
+    % check that cv::waitKey waits for at least specified time
+    function waitKey(testcase)
+      tic();
+      cv.waitKey(500);
+      elapsed = toc();
+      testcase.verifyGreaterThan(elapsed, 0.5, 'Elapsed time should be at least 0.5 seconds');
+    end
+
+    % check that highgui window can be created and destroyed
+    function createAndDestroyWindow(testcase)
+      try
+        cv.namedWindow('test window');
+      catch
+        testcase.verifyFail('could not create window');
+      end
+
+      try
+        cv.destroyWindow('test window');
+      catch
+        testcase.verifyFail('could not destroy window');
+      end
+      testcase.verifyTrue(true);
+    end
+
+  end
+end

modules/matlab/test/cv_exception.cpp

+/*
+ * file:   exception.cpp
+ * author: Hilton Bristow
+ * date:   Wed, 19 Jun 2013 11:15:15
+ *
+ * See LICENCE for full modification and redistribution details.
+ * Copyright 2013 The OpenCV Foundation
+ */
+#include <exception>
+#include <opencv2/core.hpp>
+#include "mex.h"
+
+/*
+ * exception
+ * Gateway routine
+ *   nlhs - number of return arguments
+ *   plhs - pointers to return arguments
+ *   nrhs - number of input arguments
+ *   prhs - pointers to input arguments
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+                 int nrhs, const mxArray* prhs[]) {
+
+  // call the opencv function
+  // [out =] namespace.fun(src1, ..., srcn, dst1, ..., dstn, opt1, ..., optn);
+  try {
+    throw cv::Exception(-1, "OpenCV exception thrown", __func__, __FILE__, __LINE__);
+  } catch(cv::Exception& e) {
+    mexErrMsgTxt(e.what());
+  } catch(...) {
+    mexErrMsgTxt("Incorrect exception caught!");
+  }
+}

modules/matlab/test/exception.cpp

+/*
+ * file:   exception.cpp
+ * author: Hilton Bristow
+ * date:   Wed, 19 Jun 2013 11:15:15
+ *
+ * See LICENCE for full modification and redistribution details.
+ * Copyright 2013 The OpenCV Foundation
+ */
+#include "mex.h"
+
+/*
+ * exception
+ * Gateway routine
+ *   nlhs - number of return arguments
+ *   plhs - pointers to return arguments
+ *   nrhs - number of input arguments
+ *   prhs - pointers to input arguments
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+                 int nrhs, const mxArray* prhs[]) {
+
+  // call the opencv function
+  // [out =] namespace.fun(src1, ..., srcn, dst1, ..., dstn, opt1, ..., optn);
+  try {
+    throw 1;
+  } catch(...) {
+    mexErrMsgTxt("Uncaught exception occurred!");
+  }
+}

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

modules/matlab/test/std_exception.cpp

+/*
+ * file:   exception.cpp
+ * author: Hilton Bristow
+ * date:   Wed, 19 Jun 2013 11:15:15
+ *
+ * See LICENCE for full modification and redistribution details.
+ * Copyright 2013 The OpenCV Foundation
+ */
+#include <exception>
+#include "mex.h"
+
+/*
+ * exception
+ * Gateway routine
+ *   nlhs - number of return arguments
+ *   plhs - pointers to return arguments
+ *   nrhs - number of input arguments
+ *   prhs - pointers to input arguments
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+                 int nrhs, const mxArray* prhs[]) {
+
+  // call the opencv function
+  // [out =] namespace.fun(src1, ..., srcn, dst1, ..., dstn, opt1, ..., optn);
+  try {
+    throw std::exception();
+  } catch(std::exception& e) {
+    mexErrMsgTxt(e.what());
+  } catch(...) {
+    mexErrMsgTxt("Incorrect exception caught!");
+  }
+}

modules/matlab/test/test_compiler.cpp

+/*
+ * file:   rand.cpp
+ * author: A trusty code generator
+ * date:   Wed, 19 Jun 2013 11:15:15
+ *
+ * This file was autogenerated, do not modify.
+ * See LICENCE for full modification and redistribution details.
+ * Copyright 2013 The OpenCV Foundation
+ */
+#include "mex.h"
+#include <vector>
+
+/*
+ * rand
+ * Gateway routine
+ *   nlhs - number of return arguments
+ *   plhs - pointers to return arguments
+ *   nrhs - number of input arguments
+ *   prhs - pointers to input arguments
+ */
+void mexFunction(int nlhs, mxArray* plhs[],
+                 int nrhs, const mxArray* prhs[]) {
+
+  // call the opencv function
+  // [out =] namespace.fun(src1, ..., srcn, dst1, ..., dstn, opt1, ..., optn);
+  try {
+    rand();
+  } catch(...) {
+    mexErrMsgTxt("Uncaught exception occurred in rand");
+  }
+}

modules/matlab/test/test_generator.hpp

+/*
+ * a rather innocuous-looking function which is actually
+ * part of <cstdlib>, so we can be reasonably sure its
+ * definition will be found
+ */
+#ifndef __OPENCV_MATLAB_TEST_GENERATOR_HPP_
+#define __OPENCV_MATLAB_TEST_GENERATOR_HPP_
+
+namespace cv {
+
+CV_EXPORTS_W int rand( );
+
+};
+
+#endif

modules/matlab/test/testsuite.m

+% add the opencv bindings folder
+addpath ..
+
+%setup the tests
+opencv_tests = OpenCVTest();
+
+%run the tests
+result = run(opencv_tests);
+
+% shutdown
+exit();

modules/optflow/CMakeLists.txt

+set(the_description "Optical Flow Algorithms")
+ocv_define_module(optflow opencv_core opencv_imgproc opencv_video opencv_highgui)

modules/optflow/doc/dense_optflow.rst

+Dense Optical Flow
+===================
+
+Dense optical flow algorithms compute motion for each point
+
+calcOpticalFlowSF
+-----------------
+Calculate an optical flow using "SimpleFlow" algorithm.
+
+.. ocv:function:: void calcOpticalFlowSF( InputArray from, InputArray to, OutputArray flow, int layers, int averaging_block_size, int max_flow )
+
+.. ocv:function:: calcOpticalFlowSF( InputArray from, InputArray to, OutputArray flow, int layers, int averaging_block_size, int max_flow, double sigma_dist, double sigma_color, int postprocess_window, double sigma_dist_fix, double sigma_color_fix, double occ_thr, int upscale_averaging_radius, double upscale_sigma_dist, double upscale_sigma_color, double speed_up_thr )
+
+    :param prev: First 8-bit 3-channel image.
+
+    :param next: Second 8-bit 3-channel image of the same size as ``prev``
+
+    :param flow: computed flow image that has the same size as ``prev`` and type ``CV_32FC2``
+
+    :param layers: Number of layers
+
+    :param averaging_block_size: Size of block through which we sum up when calculate cost function for pixel
+
+    :param max_flow: maximal flow that we search at each level
+
+    :param sigma_dist: vector smooth spatial sigma parameter
+
+    :param sigma_color: vector smooth color sigma parameter
+
+    :param postprocess_window: window size for postprocess cross bilateral filter
+
+    :param sigma_dist_fix: spatial sigma for postprocess cross bilateralf filter
+
+    :param sigma_color_fix: color sigma for postprocess cross bilateral filter
+
+    :param occ_thr: threshold for detecting occlusions
+
+    :param upscale_averaging_radius: window size for bilateral upscale operation
+
+    :param upscale_sigma_dist: spatial sigma for bilateral upscale operation
+
+    :param upscale_sigma_color: color sigma for bilateral upscale operation
+
+    :param speed_up_thr: threshold to detect point with irregular flow - where flow should be recalculated after upscale
+
+See [Tao2012]_. And site of project - http://graphics.berkeley.edu/papers/Tao-SAN-2012-05/.
+
+.. note::
+
+   * An example using the simpleFlow algorithm can be found at samples/simpleflow_demo.cpp
+   
+
+.. [Tao2012] Michael Tao, Jiamin Bai, Pushmeet Kohli and Sylvain Paris. SimpleFlow: A Non-iterative, Sublinear Optical Flow Algorithm. Computer Graphics Forum (Eurographics 2012)

modules/optflow/doc/optflow.rst

+******************************************
+text. Optical Flow Algorithms
+******************************************
+
+.. highlight:: cpp
+
+The opencv_optflow module includes different algorithms for tracking points
+
+.. toctree::
+    :maxdepth: 2
+
+    dense_optflow
+    motion_templates

modules/optflow/include/opencv2/optflow.hpp

+/*
+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
+                       (3-clause BSD License)
+
+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:
+
+  * 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.
+
+  * Neither the names of the copyright holders nor the names of the contributors
+    may 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 copyright holders 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.
+*/
+
+#ifndef __OPENCV_OPTFLOW_HPP__
+#define __OPENCV_OPTFLOW_HPP__
+
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+namespace optflow
+{
+    
+//! computes dense optical flow using Simple Flow algorithm
+CV_EXPORTS_W void calcOpticalFlowSF( InputArray from, InputArray to, OutputArray flow,
+                                     int layers, int averaging_block_size, int max_flow);
+
+CV_EXPORTS_W void calcOpticalFlowSF( InputArray from, InputArray to, OutputArray flow, int layers,
+                                     int averaging_block_size, int max_flow,
+                                     double sigma_dist, double sigma_color, int postprocess_window,
+                                     double sigma_dist_fix, double sigma_color_fix, double occ_thr,
+                                     int upscale_averaging_radius, double upscale_sigma_dist,
+                                     double upscale_sigma_color, double speed_up_thr );    
+    
+}
+}
+
+#include "opencv2/optflow/motempl.hpp"
+
+#endif

modules/optflow/test/test_main.cpp

+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")