Super Resolution module

modules/java/generator/rst_parser.py

 #/usr/bin/env python
 
 import os, sys, re, string, fnmatch
-allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "java", "python", "stitching", "ts", "photo", "nonfree", "videostab", "ocl"]
+allmodules = ["core", "flann", "imgproc", "ml", "highgui", "video", "features2d", "calib3d", "objdetect", "legacy", "contrib", "gpu", "androidcamera", "java", "python", "stitching", "ts", "photo", "nonfree", "videostab", "ocl", "superres"]
 verbose = False
 show_warnings = True
 show_errors = True
@@ -380,7 +380,7 @@ class RstParser(object):
 
     @classmethod
     def parse_namespace(cls, func, section_name):
-        known_namespaces = ["cv", "gpu", "flann"]
+        known_namespaces = ["cv", "gpu", "flann", "superres"]
         l = section_name.strip()
         for namespace in known_namespaces:
             if l.startswith(namespace + "::"):

modules/superres/CMakeLists.txt

+if(ANDROID OR IOS)
+  ocv_module_disable(superres)
+endif()
+
+set(the_description "Super Resolution")
+ocv_add_module(superres opencv_imgproc opencv_video OPTIONAL opencv_gpu opencv_highgui)
+ocv_module_include_directories()
+
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef /wd4127)
+
+if(HAVE_CUDA)
+  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+  ocv_source_group("Src\\Cuda" GLOB "src/cuda/*.cu")
+  ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpu/include" ${CUDA_INCLUDE_DIRS})
+
+  file(GLOB lib_cuda "src/cuda/*.cu")
+  ocv_cuda_compile(cuda_objs ${lib_cuda})
+
+  set(cuda_link_libs ${CUDA_LIBRARIES})
+else()
+  set(lib_cuda "")
+  set(cuda_objs "")
+  set(cuda_link_libs "")
+endif()
+
+ocv_glob_module_sources(SOURCES ${lib_cuda} ${cuda_objs})
+
+ocv_create_module(${cuda_link_libs})
+ocv_add_precompiled_headers(${the_module})
+
+ocv_add_accuracy_tests()
+ocv_add_perf_tests()

modules/superres/doc/super_resolution.rst

+Super Resolution
+================
+
+.. highlight:: cpp
+
+The Super Resolution module contains a set of functions and classes that can be used to solve the problem of resolution enhancement. There are a few methods implemented, most of them are descibed in the papers [Farsiu03]_ and [Mitzel09]_.
+
+
+
+superres::SuperResolution
+-------------------------
+Base class for Super Resolution algorithms.
+
+.. ocv:class:: superres::SuperResolution : public Algorithm, public superres::FrameSource
+
+The class is only used to define the common interface for the whole family of Super Resolution algorithms.
+
+
+
+superres::SuperResolution::setInput
+-----------------------------------
+Set input frame source for Super Resolution algorithm.
+
+.. ocv:function:: void superres::SuperResolution::setInput(const Ptr<FrameSource>& frameSource)
+
+    :param frameSource: Input frame source
+
+
+
+superres::SuperResolution::nextFrame
+------------------------------------
+Process next frame from input and return output result.
+
+.. ocv:function:: void superres::SuperResolution::nextFrame(OutputArray frame)
+
+    :param frame: Output result
+
+
+
+superres::SuperResolution::collectGarbage
+-----------------------------------------
+Clear all inner buffers.
+
+.. ocv:function:: void superres::SuperResolution::collectGarbage()
+
+
+
+superres::createSuperResolution_BTVL1
+-------------------------------------
+Create Bilateral TV-L1 Super Resolution.
+
+.. ocv:function:: Ptr<SuperResolution> superres::createSuperResolution_BTVL1()
+
+.. ocv:function:: Ptr<SuperResolution> superres::createSuperResolution_BTVL1_GPU()
+
+This class implements Super Resolution algorithm described in the papers [Farsiu03]_ and [Mitzel09]_ .
+
+Here are important members of the class that control the algorithm, which you can set after constructing the class instance:
+
+    * **int scale** Scale factor.
+
+    * **int iterations** Iteration count.
+
+    * **double tau** Asymptotic value of steepest descent method.
+
+    * **double lambda** Weight parameter to balance data term and smoothness term.
+
+    * **double alpha** Parameter of spacial distribution in Bilateral-TV.
+
+    * **int btvKernelSize** Kernel size of Bilateral-TV filter.
+
+    * **int blurKernelSize** Gaussian blur kernel size.
+
+    * **double blurSigma** Gaussian blur sigma.
+
+    * **int temporalAreaRadius** Radius of the temporal search area.
+
+    * **Ptr<DenseOpticalFlowExt> opticalFlow** Dense optical flow algorithm.
+
+
+
+.. [Farsiu03] S. Farsiu, D. Robinson, M. Elad, P. Milanfar. Fast and robust Super-Resolution. Proc 2003 IEEE Int Conf on Image Process, pp. 291–294, 2003.
+
+.. [Mitzel09] D. Mitzel, T. Pock, T. Schoenemann, D. Cremers. Video super resolution using duality based TV-L1 optical flow. DAGM, 2009.

modules/superres/doc/superres.rst

+**************************
+superres. Super Resolution
+**************************
+
+.. toctree::
+    :maxdepth: 2
+
+    super_resolution

modules/superres/include/opencv2/superres/optical_flow.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#ifndef __OPENCV_SUPERRES_OPTICAL_FLOW_HPP__
+#define __OPENCV_SUPERRES_OPTICAL_FLOW_HPP__
+
+#include "opencv2/core/core.hpp"
+
+namespace cv
+{
+    namespace superres
+    {
+        class CV_EXPORTS DenseOpticalFlowExt : public cv::Algorithm
+        {
+        public:
+            virtual void calc(InputArray frame0, InputArray frame1, OutputArray flow1, OutputArray flow2 = noArray()) = 0;
+            virtual void collectGarbage() = 0;
+        };
+
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_Farneback();
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_Farneback_GPU();
+
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_Simple();
+
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_DualTVL1();
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_DualTVL1_GPU();
+
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_Brox_GPU();
+
+        CV_EXPORTS Ptr<DenseOpticalFlowExt> createOptFlow_PyrLK_GPU();
+    }
+}
+
+#endif // __OPENCV_SUPERRES_OPTICAL_FLOW_HPP__

modules/superres/include/opencv2/superres/superres.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#ifndef __OPENCV_SUPERRES_HPP__
+#define __OPENCV_SUPERRES_HPP__
+
+#include "opencv2/core/core.hpp"
+
+namespace cv
+{
+    namespace superres
+    {
+        CV_EXPORTS bool initModule_superres();
+
+        class CV_EXPORTS FrameSource
+        {
+        public:
+            virtual ~FrameSource();
+
+            virtual void nextFrame(OutputArray frame) = 0;
+            virtual void reset() = 0;
+        };
+
+        CV_EXPORTS Ptr<FrameSource> createFrameSource_Empty();
+
+        CV_EXPORTS Ptr<FrameSource> createFrameSource_Video(const std::string& fileName);
+        CV_EXPORTS Ptr<FrameSource> createFrameSource_Video_GPU(const std::string& fileName);
+
+        CV_EXPORTS Ptr<FrameSource> createFrameSource_Camera(int deviceId = 0);
+
+        class CV_EXPORTS SuperResolution : public cv::Algorithm, public FrameSource
+        {
+        public:
+            void setInput(const Ptr<FrameSource>& frameSource);
+
+            void nextFrame(OutputArray frame);
+            void reset();
+
+            virtual void collectGarbage();
+
+        protected:
+            SuperResolution();
+
+            virtual void initImpl(Ptr<FrameSource>& frameSource) = 0;
+            virtual void processImpl(Ptr<FrameSource>& frameSource, OutputArray output) = 0;
+
+        private:
+            Ptr<FrameSource> frameSource_;
+            bool firstCall_;
+        };
+
+        // S. Farsiu , D. Robinson, M. Elad, P. Milanfar. Fast and robust multiframe super resolution.
+        // Dennis Mitzel, Thomas Pock, Thomas Schoenemann, Daniel Cremers. Video Super Resolution using Duality Based TV-L1 Optical Flow.
+        CV_EXPORTS Ptr<SuperResolution> createSuperResolution_BTVL1();
+        CV_EXPORTS Ptr<SuperResolution> createSuperResolution_BTVL1_GPU();
+    }
+}
+
+#endif // __OPENCV_SUPERRES_HPP__

modules/superres/perf/perf_main.cpp

+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(superres)

modules/superres/perf/perf_precomp.cpp

+#include "perf_precomp.hpp"

modules/superres/perf/perf_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_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#ifdef HAVE_CVCONFIG_H
+#include "cvconfig.h"
+#endif
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/gpumat.hpp"
+#include "opencv2/ts/ts_perf.hpp"
+#include "opencv2/superres/superres.hpp"
+#include "opencv2/superres/optical_flow.hpp"
+
+#ifdef GTEST_CREATE_SHARED_LIBRARY
+#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
+#endif
+
+#endif

modules/superres/perf/perf_superres.cpp

+#include "perf_precomp.hpp"
+
+using namespace std;
+using namespace std::tr1;
+using namespace testing;
+using namespace perf;
+using namespace cv;
+using namespace cv::superres;
+using namespace cv::gpu;
+
+#define GPU_SANITY_CHECK(mat, ...) \
+    do{ \
+        Mat gpu_##mat(mat); \
+        SANITY_CHECK(gpu_##mat, ## __VA_ARGS__); \
+    } while(0)
+
+#define CPU_SANITY_CHECK(mat, ...) \
+    do{ \
+        Mat cpu_##mat(mat); \
+        SANITY_CHECK(cpu_##mat, ## __VA_ARGS__); \
+    } while(0)
+
+namespace
+{
+    class OneFrameSource_CPU : public FrameSource
+    {
+    public:
+        explicit OneFrameSource_CPU(const Mat& frame) : frame_(frame) {}
+
+        void nextFrame(OutputArray frame)
+        {
+            frame.getMatRef() = frame_;
+        }
+
+        void reset()
+        {
+        }
+
+    private:
+        Mat frame_;
+    };
+
+    class OneFrameSource_GPU : public FrameSource
+    {
+    public:
+        explicit OneFrameSource_GPU(const GpuMat& frame) : frame_(frame) {}
+
+        void nextFrame(OutputArray frame)
+        {
+            frame.getGpuMatRef() = frame_;
+        }
+
+        void reset()
+        {
+        }
+
+    private:
+        GpuMat frame_;
+    };
+
+    class ZeroOpticalFlow : public DenseOpticalFlowExt
+    {
+    public:
+        void calc(InputArray frame0, InputArray, OutputArray flow1, OutputArray flow2)
+        {
+            cv::Size size = frame0.size();
+
+            if (!flow2.needed())
+            {
+                flow1.create(size, CV_32FC2);
+
+                if (flow1.kind() == cv::_InputArray::GPU_MAT)
+                    flow1.getGpuMatRef().setTo(cv::Scalar::all(0));
+                else
+                    flow1.getMatRef().setTo(cv::Scalar::all(0));
+            }
+            else
+            {
+                flow1.create(size, CV_32FC1);
+                flow2.create(size, CV_32FC1);
+
+                if (flow1.kind() == cv::_InputArray::GPU_MAT)
+                    flow1.getGpuMatRef().setTo(cv::Scalar::all(0));
+                else
+                    flow1.getMatRef().setTo(cv::Scalar::all(0));
+
+                if (flow2.kind() == cv::_InputArray::GPU_MAT)
+                    flow2.getGpuMatRef().setTo(cv::Scalar::all(0));
+                else
+                    flow2.getMatRef().setTo(cv::Scalar::all(0));
+            }
+        }
+
+        void collectGarbage()
+        {
+        }
+    };
+}
+
+PERF_TEST_P(Size_MatType, SuperResolution_BTVL1,
+            Combine(Values(szSmall64, szSmall128),
+                    Values(MatType(CV_8UC1), MatType(CV_8UC3))))
+{
+    declare.time(5 * 60);
+
+    const Size size = get<0>(GetParam());
+    const int type = get<1>(GetParam());
+
+    Mat frame(size, type);
+    declare.in(frame, WARMUP_RNG);
+
+    const int scale = 2;
+    const int iterations = 50;
+    const int temporalAreaRadius = 1;
+    Ptr<DenseOpticalFlowExt> opticalFlow(new ZeroOpticalFlow);
+
+    if (PERF_RUN_GPU())
+    {
+        Ptr<SuperResolution> superRes = createSuperResolution_BTVL1_GPU();
+
+        superRes->set("scale", scale);
+        superRes->set("iterations", iterations);
+        superRes->set("temporalAreaRadius", temporalAreaRadius);
+        superRes->set("opticalFlow", opticalFlow);
+
+        superRes->setInput(new OneFrameSource_GPU(GpuMat(frame)));
+
+        GpuMat dst;
+        superRes->nextFrame(dst);
+
+        TEST_CYCLE_N(10) superRes->nextFrame(dst);
+
+        GPU_SANITY_CHECK(dst);
+    }
+    else
+    {
+        Ptr<SuperResolution> superRes = createSuperResolution_BTVL1();
+
+        superRes->set("scale", scale);
+        superRes->set("iterations", iterations);
+        superRes->set("temporalAreaRadius", temporalAreaRadius);
+        superRes->set("opticalFlow", opticalFlow);
+
+        superRes->setInput(new OneFrameSource_CPU(frame));
+
+        Mat dst;
+        superRes->nextFrame(dst);
+
+        TEST_CYCLE_N(10) superRes->nextFrame(dst);
+
+        CPU_SANITY_CHECK(dst);
+    }
+}

modules/superres/src/cuda/btv_l1_gpu.cu

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/transform.hpp"
+#include "opencv2/gpu/device/vec_traits.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace btv_l1_device
+{
+    void buildMotionMaps(PtrStepSzf forwardMotionX, PtrStepSzf forwardMotionY,
+                         PtrStepSzf backwardMotionX, PtrStepSzf bacwardMotionY,
+                         PtrStepSzf forwardMapX, PtrStepSzf forwardMapY,
+                         PtrStepSzf backwardMapX, PtrStepSzf backwardMapY);
+
+    template <int cn>
+    void upscale(const PtrStepSzb src, PtrStepSzb dst, int scale, cudaStream_t stream);
+
+    void diffSign(PtrStepSzf src1, PtrStepSzf src2, PtrStepSzf dst, cudaStream_t stream);
+
+    void loadBtvWeights(const float* weights, size_t count);
+    template <int cn> void calcBtvRegularization(PtrStepSzb src, PtrStepSzb dst, int ksize);
+}
+
+namespace btv_l1_device
+{
+    __global__ void buildMotionMapsKernel(const PtrStepSzf forwardMotionX, const PtrStepf forwardMotionY,
+                                          PtrStepf backwardMotionX, PtrStepf backwardMotionY,
+                                          PtrStepf forwardMapX, PtrStepf forwardMapY,
+                                          PtrStepf backwardMapX, PtrStepf backwardMapY)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x >= forwardMotionX.cols || y >= forwardMotionX.rows)
+            return;
+
+        const float fx = forwardMotionX(y, x);
+        const float fy = forwardMotionY(y, x);
+
+        const float bx = backwardMotionX(y, x);
+        const float by = backwardMotionY(y, x);
+
+        forwardMapX(y, x) = x + bx;
+        forwardMapY(y, x) = y + by;
+
+        backwardMapX(y, x) = x + fx;
+        backwardMapY(y, x) = y + fy;
+    }
+
+    void buildMotionMaps(PtrStepSzf forwardMotionX, PtrStepSzf forwardMotionY,
+                         PtrStepSzf backwardMotionX, PtrStepSzf bacwardMotionY,
+                         PtrStepSzf forwardMapX, PtrStepSzf forwardMapY,
+                         PtrStepSzf backwardMapX, PtrStepSzf backwardMapY)
+    {
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(forwardMapX.cols, block.x), divUp(forwardMapX.rows, block.y));
+
+        buildMotionMapsKernel<<<grid, block>>>(forwardMotionX, forwardMotionY,
+                                               backwardMotionX, bacwardMotionY,
+                                               forwardMapX, forwardMapY,
+                                               backwardMapX, backwardMapY);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    template <typename T>
+    __global__ void upscaleKernel(const PtrStepSz<T> src, PtrStep<T> dst, const int scale)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x >= src.cols || y >= src.rows)
+            return;
+
+        dst(y * scale, x * scale) = src(y, x);
+    }
+
+    template <int cn>
+    void upscale(const PtrStepSzb src, PtrStepSzb dst, int scale, cudaStream_t stream)
+    {
+        typedef typename TypeVec<float, cn>::vec_type src_t;
+
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+
+        upscaleKernel<src_t><<<grid, block, 0, stream>>>((PtrStepSz<src_t>) src, (PtrStepSz<src_t>) dst, scale);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    template void upscale<1>(const PtrStepSzb src, PtrStepSzb dst, int scale, cudaStream_t stream);
+    template void upscale<3>(const PtrStepSzb src, PtrStepSzb dst, int scale, cudaStream_t stream);
+    template void upscale<4>(const PtrStepSzb src, PtrStepSzb dst, int scale, cudaStream_t stream);
+
+    __device__ __forceinline__ float diffSign(float a, float b)
+    {
+        return a > b ? 1.0f : a < b ? -1.0f : 0.0f;
+    }
+    __device__ __forceinline__ float3 diffSign(const float3& a, const float3& b)
+    {
+        return make_float3(
+            a.x > b.x ? 1.0f : a.x < b.x ? -1.0f : 0.0f,
+            a.y > b.y ? 1.0f : a.y < b.y ? -1.0f : 0.0f,
+            a.z > b.z ? 1.0f : a.z < b.z ? -1.0f : 0.0f
+        );
+    }
+    __device__ __forceinline__ float4 diffSign(const float4& a, const float4& b)
+    {
+        return make_float4(
+            a.x > b.x ? 1.0f : a.x < b.x ? -1.0f : 0.0f,
+            a.y > b.y ? 1.0f : a.y < b.y ? -1.0f : 0.0f,
+            a.z > b.z ? 1.0f : a.z < b.z ? -1.0f : 0.0f,
+            0.0f
+        );
+    }
+
+    struct DiffSign : binary_function<float, float, float>
+    {
+        __device__ __forceinline__ float operator ()(float a, float b) const
+        {
+            return diffSign(a, b);
+        }
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits<btv_l1_device::DiffSign> : DefaultTransformFunctorTraits<btv_l1_device::DiffSign>
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace btv_l1_device
+{
+    void diffSign(PtrStepSzf src1, PtrStepSzf src2, PtrStepSzf dst, cudaStream_t stream)
+    {
+        transform(src1, src2, dst, DiffSign(), WithOutMask(), stream);
+    }
+
+    __constant__ float c_btvRegWeights[16*16];
+
+    template <typename T>
+    __global__ void calcBtvRegularizationKernel(const PtrStepSz<T> src, PtrStep<T> dst, const int ksize)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x + ksize;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y + ksize;
+
+        if (y >= src.rows - ksize || x >= src.cols - ksize)
+            return;
+
+        const T srcVal = src(y, x);
+
+        T dstVal = VecTraits<T>::all(0);
+
+        for (int m = 0, count = 0; m <= ksize; ++m)
+        {
+            for (int l = ksize; l + m >= 0; --l, ++count)
+                dstVal = dstVal + c_btvRegWeights[count] * (diffSign(srcVal, src(y + m, x + l)) - diffSign(src(y - m, x - l), srcVal));
+        }
+
+        dst(y, x) = dstVal;
+    }
+
+    void loadBtvWeights(const float* weights, size_t count)
+    {
+        cudaSafeCall( cudaMemcpyToSymbol(c_btvRegWeights, weights, count * sizeof(float)) );
+    }
+
+    template <int cn>
+    void calcBtvRegularization(PtrStepSzb src, PtrStepSzb dst, int ksize)
+    {
+        typedef typename TypeVec<float, cn>::vec_type src_t;
+
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+
+        calcBtvRegularizationKernel<src_t><<<grid, block>>>((PtrStepSz<src_t>) src, (PtrStepSz<src_t>) dst, ksize);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    template void calcBtvRegularization<1>(PtrStepSzb src, PtrStepSzb dst, int ksize);
+    template void calcBtvRegularization<3>(PtrStepSzb src, PtrStepSzb dst, int ksize);
+    template void calcBtvRegularization<4>(PtrStepSzb src, PtrStepSzb dst, int ksize);
+}

modules/superres/src/frame_source.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#include "precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+using namespace cv::superres;
+using namespace cv::superres::detail;
+
+cv::superres::FrameSource::~FrameSource()
+{
+}
+
+//////////////////////////////////////////////////////
+// EmptyFrameSource
+
+namespace
+{
+    class EmptyFrameSource : public FrameSource
+    {
+    public:
+        void nextFrame(OutputArray frame);
+        void reset();
+    };
+
+    void EmptyFrameSource::nextFrame(OutputArray frame)
+    {
+        frame.release();
+    }
+
+    void EmptyFrameSource::reset()
+    {
+    }
+}
+
+Ptr<FrameSource> cv::superres::createFrameSource_Empty()
+{
+    return new EmptyFrameSource;
+}
+
+//////////////////////////////////////////////////////
+// VideoFrameSource & CameraFrameSource
+
+#ifndef HAVE_OPENCV_HIGHGUI
+
+Ptr<FrameSource> cv::superres::createFrameSource_Video(const string& fileName)
+{
+    (void) fileName;
+    CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform");
+    return Ptr<FrameSource>();
+}
+
+Ptr<FrameSource> cv::superres::createFrameSource_Camera(int deviceId)
+{
+    (void) deviceId;
+    CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform");
+    return Ptr<FrameSource>();
+}
+
+#else // HAVE_OPENCV_HIGHGUI
+
+namespace
+{
+    class CaptureFrameSource : public FrameSource
+    {
+    public:
+        void nextFrame(OutputArray frame);
+
+    protected:
+        VideoCapture vc_;
+
+    private:
+        Mat frame_;
+    };
+
+    void CaptureFrameSource::nextFrame(OutputArray _frame)
+    {
+        if (_frame.kind() == _InputArray::MAT)
+        {
+            vc_ >> _frame.getMatRef();
+        }
+        else
+        {
+            vc_ >> frame_;
+            arrCopy(frame_, _frame);
+        }
+    }
+
+    class VideoFrameSource : public CaptureFrameSource
+    {
+    public:
+        VideoFrameSource(const string& fileName);
+
+        void reset();
+
+    private:
+        string fileName_;
+    };
+
+    VideoFrameSource::VideoFrameSource(const string& fileName) : fileName_(fileName)
+    {
+        reset();
+    }
+
+    void VideoFrameSource::reset()
+    {
+        vc_.release();
+        vc_.open(fileName_);
+        CV_Assert( vc_.isOpened() );
+    }
+
+    class CameraFrameSource : public CaptureFrameSource
+    {
+    public:
+        CameraFrameSource(int deviceId);
+
+        void reset();
+
+    private:
+        int deviceId_;
+    };
+
+    CameraFrameSource::CameraFrameSource(int deviceId) : deviceId_(deviceId)
+    {
+        reset();
+    }
+
+    void CameraFrameSource::reset()
+    {
+        vc_.release();
+        vc_.open(deviceId_);
+        CV_Assert( vc_.isOpened() );
+    }
+}
+
+Ptr<FrameSource> cv::superres::createFrameSource_Video(const string& fileName)
+{
+    return new VideoFrameSource(fileName);
+}
+
+Ptr<FrameSource> cv::superres::createFrameSource_Camera(int deviceId)
+{
+    return new CameraFrameSource(deviceId);
+}
+
+#endif // HAVE_OPENCV_HIGHGUI
+
+//////////////////////////////////////////////////////
+// VideoFrameSource_GPU
+
+#ifndef HAVE_OPENCV_GPU
+
+Ptr<FrameSource> cv::superres::createFrameSource_Video_GPU(const string& fileName)
+{
+    (void) fileName;
+    CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform");
+    return Ptr<FrameSource>();
+}
+
+#else // HAVE_OPENCV_GPU
+
+namespace
+{
+    class VideoFrameSource_GPU : public FrameSource
+    {
+    public:
+        VideoFrameSource_GPU(const string& fileName);
+
+        void nextFrame(OutputArray frame);
+        void reset();
+
+    private:
+        string fileName_;
+        VideoReader_GPU reader_;
+        GpuMat frame_;
+    };
+
+    VideoFrameSource_GPU::VideoFrameSource_GPU(const string& fileName) : fileName_(fileName)
+    {
+        reset();
+    }
+
+    void VideoFrameSource_GPU::nextFrame(OutputArray _frame)
+    {
+        if (_frame.kind() == _InputArray::GPU_MAT)
+        {
+            bool res = reader_.read(_frame.getGpuMatRef());
+            if (!res)
+                _frame.release();
+        }
+        else
+        {
+            bool res = reader_.read(frame_);
+            if (!res)
+                _frame.release();
+            else
+                arrCopy(frame_, _frame);
+        }
+    }
+
+    void VideoFrameSource_GPU::reset()
+    {
+        reader_.close();
+        reader_.open(fileName_);
+        CV_Assert( reader_.isOpened() );
+    }
+}
+
+Ptr<FrameSource> cv::superres::createFrameSource_Video_GPU(const string& fileName)
+{
+    return new VideoFrameSource(fileName);
+}
+
+#endif // HAVE_OPENCV_GPU

modules/superres/src/input_array_utility.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#include "precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+Mat cv::superres::arrGetMat(InputArray arr, Mat& buf)
+{
+    switch (arr.kind())
+    {
+    case _InputArray::GPU_MAT:
+        arr.getGpuMat().download(buf);
+        return buf;
+
+    case _InputArray::OPENGL_BUFFER:
+        arr.getOGlBuffer().copyTo(buf);
+        return buf;
+
+    case _InputArray::OPENGL_TEXTURE:
+        arr.getOGlTexture2D().copyTo(buf);
+        return buf;
+
+    default:
+        return arr.getMat();
+    }
+}
+
+GpuMat cv::superres::arrGetGpuMat(InputArray arr, GpuMat& buf)
+{
+    switch (arr.kind())
+    {
+    case _InputArray::GPU_MAT:
+        return arr.getGpuMat();
+
+    case _InputArray::OPENGL_BUFFER:
+        arr.getOGlBuffer().copyTo(buf);
+        return buf;
+
+    case _InputArray::OPENGL_TEXTURE:
+        arr.getOGlTexture2D().copyTo(buf);
+        return buf;
+
+    default:
+        buf.upload(arr.getMat());
+        return buf;
+    }
+}
+
+namespace
+{
+    void mat2mat(InputArray src, OutputArray dst)
+    {
+        src.getMat().copyTo(dst);
+    }
+    void arr2buf(InputArray src, OutputArray dst)
+    {
+        dst.getOGlBufferRef().copyFrom(src);
+    }
+    void arr2tex(InputArray src, OutputArray dst)
+    {
+        dst.getOGlTexture2D().copyFrom(src);
+    }
+    void mat2gpu(InputArray src, OutputArray dst)
+    {
+        dst.getGpuMatRef().upload(src.getMat());
+    }
+    void buf2arr(InputArray src, OutputArray dst)
+    {
+        src.getOGlBuffer().copyTo(dst);
+    }
+    void tex2arr(InputArray src, OutputArray dst)
+    {
+        src.getOGlTexture2D().copyTo(dst);
+    }
+    void gpu2mat(InputArray src, OutputArray dst)
+    {
+        GpuMat d = src.getGpuMat();
+        dst.create(d.size(), d.type());
+        Mat m = dst.getMat();
+        d.download(m);
+    }
+    void gpu2gpu(InputArray src, OutputArray dst)
+    {
+        src.getGpuMat().copyTo(dst.getGpuMatRef());
+    }
+}
+
+void cv::superres::arrCopy(InputArray src, OutputArray dst)
+{
+    typedef void (*func_t)(InputArray src, OutputArray dst);
+    static const func_t funcs[10][10] =
+    {
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+        {0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, arr2tex, mat2gpu},
+        {0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, arr2tex, mat2gpu},
+        {0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, arr2tex, mat2gpu},
+        {0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, arr2tex, mat2gpu},
+        {0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, arr2tex, mat2gpu},
+        {0, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, mat2mat, arr2buf, arr2tex, mat2gpu},
+        {0, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr, buf2arr},
+        {0, tex2arr, tex2arr, tex2arr, tex2arr, tex2arr, tex2arr, tex2arr, tex2arr, tex2arr},
+        {0, gpu2mat, gpu2mat, gpu2mat, gpu2mat, gpu2mat, gpu2mat, arr2buf, arr2tex, gpu2gpu}
+    };
+
+    const int src_kind = src.kind() >> _InputArray::KIND_SHIFT;
+    const int dst_kind = dst.kind() >> _InputArray::KIND_SHIFT;
+
+    CV_DbgAssert( src_kind >= 0 && src_kind < 10 );
+    CV_DbgAssert( dst_kind >= 0 && dst_kind < 10 );
+
+    const func_t func = funcs[src_kind][dst_kind];
+    CV_DbgAssert( func != 0 );
+
+    func(src, dst);
+}
+
+namespace
+{
+    void convertToCn(InputArray src, OutputArray dst, int cn)
+    {
+        CV_Assert( src.channels() == 1 || src.channels() == 3 || src.channels() == 4 );
+        CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+
+        static const int codes[5][5] =
+        {
+            {-1, -1, -1, -1, -1},
+            {-1, -1, -1, COLOR_GRAY2BGR, COLOR_GRAY2BGRA},
+            {-1, -1, -1, -1, -1},
+            {-1, COLOR_BGR2GRAY, -1, -1, COLOR_BGR2BGRA},
+            {-1, COLOR_BGRA2GRAY, -1, COLOR_BGRA2BGR, -1},
+        };
+
+        const int code = codes[src.channels()][cn];
+        CV_DbgAssert( code >= 0 );
+
+        switch (src.kind())
+        {
+        case _InputArray::GPU_MAT:
+            #ifdef HAVE_OPENCV_GPU
+                gpu::cvtColor(src.getGpuMat(), dst.getGpuMatRef(), code, cn);
+            #else
+                CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform");
+            #endif
+            break;
+
+        default:
+            cvtColor(src, dst, code, cn);
+            break;
+        }
+    }
+
+    void convertToDepth(InputArray src, OutputArray dst, int depth)
+    {
+        CV_Assert( src.depth() <= CV_64F );
+        CV_Assert( depth == CV_8U || depth == CV_32F );
+
+        static const double maxVals[] =
+        {
+            numeric_limits<uchar>::max(),
+            numeric_limits<schar>::max(),
+            numeric_limits<ushort>::max(),
+            numeric_limits<short>::max(),
+            numeric_limits<int>::max(),
+            1.0,
+            1.0,
+        };
+
+        const double scale = maxVals[depth] / maxVals[src.depth()];
+
+        switch (src.kind())
+        {
+        case _InputArray::GPU_MAT:
+            src.getGpuMat().convertTo(dst.getGpuMatRef(), depth, scale);
+            break;
+
+        default:
+            src.getMat().convertTo(dst, depth, scale);
+            break;
+        }
+    }
+}
+
+Mat cv::superres::convertToType(const Mat& src, int type, Mat& buf0, Mat& buf1)
+{
+    if (src.type() == type)
+        return src;
+
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
+
+    if (src.depth() == depth)
+    {
+        convertToCn(src, buf0, cn);
+        return buf0;
+    }
+
+    if (src.channels() == cn)
+    {
+        convertToDepth(src, buf1, depth);
+        return buf1;
+    }
+
+    convertToCn(src, buf0, cn);
+    convertToDepth(buf0, buf1, depth);
+    return buf1;
+}
+
+GpuMat cv::superres::convertToType(const GpuMat& src, int type, GpuMat& buf0, GpuMat& buf1)
+{
+    if (src.type() == type)
+        return src;
+
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
+
+    if (src.depth() == depth)
+    {
+        convertToCn(src, buf0, cn);
+        return buf0;
+    }
+
+    if (src.channels() == cn)
+    {
+        convertToDepth(src, buf1, depth);
+        return buf1;
+    }
+
+    convertToCn(src, buf0, cn);
+    convertToDepth(buf0, buf1, depth);
+    return buf1;
+}

modules/superres/src/input_array_utility.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#ifndef __OPENCV_SUPERRES_INPUT_ARRAY_UTILITY_HPP__
+#define __OPENCV_SUPERRES_INPUT_ARRAY_UTILITY_HPP__
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/gpumat.hpp"
+
+namespace cv
+{
+    namespace superres
+    {
+        CV_EXPORTS Mat arrGetMat(InputArray arr, Mat& buf);
+        CV_EXPORTS gpu::GpuMat arrGetGpuMat(InputArray arr, gpu::GpuMat& buf);
+
+        CV_EXPORTS void arrCopy(InputArray src, OutputArray dst);
+
+        CV_EXPORTS Mat convertToType(const Mat& src, int type, Mat& buf0, Mat& buf1);
+        CV_EXPORTS gpu::GpuMat convertToType(const gpu::GpuMat& src, int type, gpu::GpuMat& buf0, gpu::GpuMat& buf1);
+    }
+}
+
+#endif // __OPENCV_SUPERRES_INPUT_ARRAY_UTILITY_HPP__

modules/superres/src/precomp.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#include "precomp.hpp"

modules/superres/src/precomp.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include <vector>
+#include <limits>
+
+#ifdef HAVE_CVCONFIG_H
+  #include "cvconfig.h"
+#endif
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/gpumat.hpp"
+#include "opencv2/core/opengl_interop.hpp"
+#include "opencv2/core/internal.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/video/tracking.hpp"
+
+#ifdef HAVE_OPENCV_GPU
+    #include "opencv2/gpu/gpu.hpp"
+    #ifdef HAVE_CUDA
+        #include "opencv2/gpu/stream_accessor.hpp"
+    #endif
+#endif
+
+#ifdef HAVE_OPENCV_HIGHGUI
+    #include "opencv2/highgui/highgui.hpp"
+#endif
+
+#include "opencv2/superres/superres.hpp"
+#include "opencv2/superres/optical_flow.hpp"
+#include "input_array_utility.hpp"
+
+#include "ring_buffer.hpp"
+
+#endif /* __OPENCV_PRECOMP_H__ */

modules/superres/src/ring_buffer.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#ifndef __RING_BUFFER_HPP__
+#define __RING_BUFFER_HPP__
+
+#include "precomp.hpp"
+
+namespace cv
+{
+    namespace superres
+    {
+        namespace detail
+        {
+            template <typename T, class A>
+            inline const T& at(int index, const std::vector<T, A>& items)
+            {
+                const int len = static_cast<int>(items.size());
+                if (index < 0)
+                    index -= ((index - len + 1) / len) * len;
+                if (index >= len)
+                    index %= len;
+                return items[index];
+            }
+
+            template <typename T, class A>
+            inline T& at(int index, std::vector<T, A>& items)
+            {
+                const int len = static_cast<int>(items.size());
+                if (index < 0)
+                    index -= ((index - len + 1) / len) * len;
+                if (index >= len)
+                    index %= len;
+                return items[index];
+            }
+        }
+    }
+}
+
+#endif // __RING_BUFFER_HPP__

modules/superres/src/super_resolution.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009-2011, Willow Garage Inc., 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.
+//
+//M*/
+
+#include "precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::superres;
+
+bool cv::superres::initModule_superres()
+{
+    return !createSuperResolution_BTVL1().empty();
+}
+
+cv::superres::SuperResolution::SuperResolution()
+{
+    frameSource_ = createFrameSource_Empty();
+    firstCall_ = true;
+}
+
+void cv::superres::SuperResolution::setInput(const Ptr<FrameSource>& frameSource)
+{
+    frameSource_ = frameSource;
+    firstCall_ = true;
+}
+
+void cv::superres::SuperResolution::nextFrame(OutputArray frame)
+{
+    if (firstCall_)
+    {
+        initImpl(frameSource_);
+        firstCall_ = false;
+    }
+
+    processImpl(frameSource_, frame);
+}
+
+void cv::superres::SuperResolution::reset()
+{
+    frameSource_->reset();
+    firstCall_ = true;
+}
+
+void cv::superres::SuperResolution::collectGarbage()
+{
+}

modules/superres/test/test_main.cpp

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

modules/superres/test/test_precomp.cpp

+#include "test_precomp.hpp"

modules/superres/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__
+
+#ifdef HAVE_CVCONFIG_H
+#include "cvconfig.h"
+#endif
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/core/core.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/ts/ts.hpp"
+#include "opencv2/superres/superres.hpp"
+#include "input_array_utility.hpp"
+
+#endif

modules/superres/test/test_superres.cpp

+#include "test_precomp.hpp"
+
+class AllignedFrameSource : public cv::superres::FrameSource
+{
+public:
+    AllignedFrameSource(const cv::Ptr<cv::superres::FrameSource>& base, int scale);
+
+    void nextFrame(cv::OutputArray frame);
+    void reset();
+
+private:
+    cv::Ptr<cv::superres::FrameSource> base_;
+    cv::Mat origFrame_;
+    int scale_;
+};
+
+AllignedFrameSource::AllignedFrameSource(const cv::Ptr<cv::superres::FrameSource>& base, int scale) :
+    base_(base), scale_(scale)
+{
+    CV_Assert( !base_.empty() );
+}
+
+void AllignedFrameSource::nextFrame(cv::OutputArray frame)
+{
+    base_->nextFrame(origFrame_);
+
+    if (origFrame_.rows % scale_ == 0 && origFrame_.cols % scale_ == 0)
+    {
+        cv::superres::arrCopy(origFrame_, frame);
+    }
+    else
+    {
+        cv::Rect ROI(0, 0, (origFrame_.cols / scale_) * scale_, (origFrame_.rows / scale_) * scale_);
+        cv::superres::arrCopy(origFrame_(ROI), frame);
+    }
+}
+
+void AllignedFrameSource::reset()
+{
+    base_->reset();
+}
+
+class DegradeFrameSource : public cv::superres::FrameSource
+{
+public:
+    DegradeFrameSource(const cv::Ptr<cv::superres::FrameSource>& base, int scale);
+
+    void nextFrame(cv::OutputArray frame);
+    void reset();
+
+private:
+    cv::Ptr<cv::superres::FrameSource> base_;
+    cv::Mat origFrame_;
+    cv::Mat blurred_;
+    cv::Mat deg_;
+    double iscale_;
+};
+
+DegradeFrameSource::DegradeFrameSource(const cv::Ptr<cv::superres::FrameSource>& base, int scale) :
+    base_(base), iscale_(1.0 / scale)
+{
+    CV_Assert( !base_.empty() );
+}
+
+void addGaussNoise(cv::Mat& image, double sigma)
+{
+    cv::Mat noise(image.size(), CV_32FC(image.channels()));
+    cvtest::TS::ptr()->get_rng().fill(noise, cv::RNG::NORMAL, 0.0, sigma);
+
+    cv::addWeighted(image, 1.0, noise, 1.0, 0.0, image, image.depth());
+}
+
+void addSpikeNoise(cv::Mat& image, int frequency)
+{
+    cv::Mat_<uchar> mask(image.size(), 0);
+
+    for (int y = 0; y < mask.rows; ++y)
+    {
+        for (int x = 0; x < mask.cols; ++x)
+        {
+            if (cvtest::TS::ptr()->get_rng().uniform(0, frequency) < 1)
+                mask(y, x) = 255;
+        }
+    }
+
+    image.setTo(cv::Scalar::all(255), mask);
+}
+
+void DegradeFrameSource::nextFrame(cv::OutputArray frame)
+{
+    base_->nextFrame(origFrame_);
+
+    cv::GaussianBlur(origFrame_, blurred_, cv::Size(5, 5), 0);
+    cv::resize(blurred_, deg_, cv::Size(), iscale_, iscale_, cv::INTER_NEAREST);
+
+    addGaussNoise(deg_, 10.0);
+    addSpikeNoise(deg_, 500);
+
+    cv::superres::arrCopy(deg_, frame);
+}
+
+void DegradeFrameSource::reset()
+{
+    base_->reset();
+}
+
+double MSSIM(const cv::Mat& i1, const cv::Mat& i2)
+{
+    const double C1 = 6.5025;
+    const double C2 = 58.5225;
+
+    const int depth = CV_32F;
+
+    cv::Mat I1, I2;
+    i1.convertTo(I1, depth);
+    i2.convertTo(I2, depth);
+
+    cv::Mat I2_2  = I2.mul(I2); // I2^2
+    cv::Mat I1_2  = I1.mul(I1); // I1^2
+    cv::Mat I1_I2 = I1.mul(I2); // I1 * I2
+
+    cv::Mat mu1, mu2;
+    cv::GaussianBlur(I1, mu1, cv::Size(11, 11), 1.5);
+    cv::GaussianBlur(I2, mu2, cv::Size(11, 11), 1.5);
+
+    cv::Mat mu1_2   = mu1.mul(mu1);
+    cv::Mat mu2_2   = mu2.mul(mu2);
+    cv::Mat mu1_mu2 = mu1.mul(mu2);
+
+    cv::Mat sigma1_2, sigma2_2, sigma12;
+
+    cv::GaussianBlur(I1_2, sigma1_2, cv::Size(11, 11), 1.5);
+    sigma1_2 -= mu1_2;
+
+    cv::GaussianBlur(I2_2, sigma2_2, cv::Size(11, 11), 1.5);
+    sigma2_2 -= mu2_2;
+
+    cv::GaussianBlur(I1_I2, sigma12, cv::Size(11, 11), 1.5);
+    sigma12 -= mu1_mu2;
+
+    cv::Mat t1, t2;
+    cv::Mat numerator;
+    cv::Mat denominator;
+
+    // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+    t1 = 2 * mu1_mu2 + C1;
+    t2 = 2 * sigma12 + C2;
+    numerator = t1.mul(t2);
+
+    // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+    t1 = mu1_2 + mu2_2 + C1;
+    t2 = sigma1_2 + sigma2_2 + C2;
+    denominator = t1.mul(t2);
+
+    // ssim_map =  numerator./denominator;
+    cv::Mat ssim_map;
+    cv::divide(numerator, denominator, ssim_map);
+
+    // mssim = average of ssim map
+    cv::Scalar mssim = cv::mean(ssim_map);
+
+    if (i1.channels() == 1)
+        return mssim[0];
+
+    return (mssim[0] + mssim[1] + mssim[3]) / 3;
+}
+
+class SuperResolution : public testing::Test
+{
+public:
+    void RunTest(cv::Ptr<cv::superres::SuperResolution> superRes);
+};
+
+void SuperResolution::RunTest(cv::Ptr<cv::superres::SuperResolution> superRes)
+{
+    const std::string inputVideoName = cvtest::TS::ptr()->get_data_path() + "car.avi";
+    const int scale = 2;
+    const int iterations = 100;
+    const int temporalAreaRadius = 2;
+
+    ASSERT_FALSE( superRes.empty() );
+
+    const int btvKernelSize = superRes->getInt("btvKernelSize");
+
+    superRes->set("scale", scale);
+    superRes->set("iterations", iterations);
+    superRes->set("temporalAreaRadius", temporalAreaRadius);
+
+    cv::Ptr<cv::superres::FrameSource> goldSource(new AllignedFrameSource(cv::superres::createFrameSource_Video(inputVideoName), scale));
+    cv::Ptr<cv::superres::FrameSource> lowResSource(new DegradeFrameSource(new AllignedFrameSource(cv::superres::createFrameSource_Video(inputVideoName), scale), scale));
+
+    // skip first frame
+    cv::Mat frame;
+
+    lowResSource->nextFrame(frame);
+    goldSource->nextFrame(frame);
+
+    cv::Rect inner(btvKernelSize, btvKernelSize, frame.cols - 2 * btvKernelSize, frame.rows - 2 * btvKernelSize);
+
+    superRes->setInput(lowResSource);
+
+    double srAvgMSSIM = 0.0;
+    const int count = 10;
+
+    cv::Mat goldFrame, superResFrame;
+    for (int i = 0; i < count; ++i)
+    {
+        goldSource->nextFrame(goldFrame);
+        ASSERT_FALSE( goldFrame.empty() );
+
+        superRes->nextFrame(superResFrame);
+        ASSERT_FALSE( superResFrame.empty() );
+
+        const double srMSSIM = MSSIM(goldFrame(inner), superResFrame);
+
+        srAvgMSSIM += srMSSIM;
+    }
+
+    srAvgMSSIM /= count;
+
+    EXPECT_GE( srAvgMSSIM, 0.5 );
+}
+
+TEST_F(SuperResolution, BTVL1)
+{
+    RunTest(cv::superres::createSuperResolution_BTVL1());
+}
+
+#if defined(HAVE_OPENCV_GPU) && defined(HAVE_CUDA)
+
+TEST_F(SuperResolution, BTVL1_GPU)
+{
+    RunTest(cv::superres::createSuperResolution_BTVL1_GPU());
+}
+
+#endif

samples/gpu/CMakeLists.txt

 SET(OPENCV_GPU_SAMPLES_REQUIRED_DEPS opencv_core opencv_flann opencv_imgproc opencv_highgui
                                      opencv_ml opencv_video opencv_objdetect opencv_features2d
                                      opencv_calib3d opencv_legacy opencv_contrib opencv_gpu
-                                     opencv_nonfree)
+                                     opencv_nonfree opencv_superres)
 
 ocv_check_dependencies(${OPENCV_GPU_SAMPLES_REQUIRED_DEPS})
 

samples/gpu/super_resolution.cpp

+#include <iostream>
+#include <iomanip>
+#include <string>
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/contrib/contrib.hpp"
+#include "opencv2/superres/superres.hpp"
+#include "opencv2/superres/optical_flow.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::superres;
+
+#define MEASURE_TIME(op) \
+    { \
+        TickMeter tm; \
+        tm.start(); \
+        op; \
+        tm.stop(); \
+        cout << tm.getTimeSec() << " sec" << endl; \
+    }
+
+static Ptr<DenseOpticalFlowExt> createOptFlow(const string& name, bool useGpu)
+{
+    if (name == "farneback")
+    {
+        if (useGpu)
+            return createOptFlow_Farneback_GPU();
+        else
+            return createOptFlow_Farneback();
+    }
+    else if (name == "simple")
+        return createOptFlow_Simple();
+    else if (name == "tvl1")
+    {
+        if (useGpu)
+            return createOptFlow_DualTVL1_GPU();
+        else
+            return createOptFlow_DualTVL1();
+    }
+    else if (name == "brox")
+        return createOptFlow_Brox_GPU();
+    else if (name == "pyrlk")
+        return createOptFlow_PyrLK_GPU();
+    else
+    {
+        cerr << "Incorrect Optical Flow algorithm - " << name << endl;
+        exit(-1);
+    }
+
+    return Ptr<DenseOpticalFlowExt>();
+}
+
+int main(int argc, const char* argv[])
+{
+    CommandLineParser cmd(argc, argv,
+        "{ v   | video      |           | Input video }"
+        "{ o   | output     |           | Output video }"
+        "{ s   | scale      | 4         | Scale factor }"
+        "{ i   | iterations | 180       | Iteration count }"
+        "{ t   | temporal   | 4         | Radius of the temporal search area }"
+        "{ f   | flow       | farneback | Optical flow algorithm (farneback, simple, tvl1, brox, pyrlk) }"
+        "{ gpu | gpu        | false     | Use GPU }"
+        "{ h   | help       | false     | Print help message }"
+    );
+
+    if (cmd.get<bool>("help"))
+    {
+        cout << "This sample demonstrates Super Resolution algorithms for video sequence" << endl;
+        cmd.printParams();
+        return 0;
+    }
+
+    const string inputVideoName = cmd.get<string>("video");
+    const string outputVideoName = cmd.get<string>("output");
+    const int scale = cmd.get<int>("scale");
+    const int iterations = cmd.get<int>("iterations");
+    const int temporalAreaRadius = cmd.get<int>("temporal");
+    const string optFlow = cmd.get<string>("flow");
+    const bool useGpu = cmd.get<bool>("gpu");
+
+    Ptr<SuperResolution> superRes;
+    if (useGpu)
+        superRes = createSuperResolution_BTVL1_GPU();
+    else
+        superRes = createSuperResolution_BTVL1();
+
+    superRes->set("scale", scale);
+    superRes->set("iterations", iterations);
+    superRes->set("temporalAreaRadius", temporalAreaRadius);
+    superRes->set("opticalFlow", createOptFlow(optFlow, useGpu));
+
+    Ptr<FrameSource> frameSource;
+    if (useGpu)
+    {
+        // Try to use gpu Video Decoding
+        try
+        {
+            frameSource = createFrameSource_Video_GPU(inputVideoName);
+            Mat frame;
+            frameSource->nextFrame(frame);
+        }
+        catch (const cv::Exception&)
+        {
+            frameSource.release();
+        }
+    }
+    if (frameSource.empty())
+        frameSource = createFrameSource_Video(inputVideoName);
+
+    // skip first frame, it is usually corrupted
+    {
+        Mat frame;
+        frameSource->nextFrame(frame);
+        cout << "Input           : " << inputVideoName << " " << frame.size() << endl;
+        cout << "Scale factor    : " << scale << endl;
+        cout << "Iterations      : " << iterations << endl;
+        cout << "Temporal radius : " << temporalAreaRadius << endl;
+        cout << "Optical Flow    : " << optFlow << endl;
+        cout << "Mode            : " << (useGpu ? "GPU" : "CPU") << endl;
+    }
+
+    superRes->setInput(frameSource);
+
+    VideoWriter writer;
+
+    for (int i = 0;; ++i)
+    {
+        cout << '[' << setw(3) << i << "] : ";
+
+        Mat result;
+        MEASURE_TIME(superRes->nextFrame(result));
+
+        if (result.empty())
+            break;
+
+        imshow("Super Resolution", result);
+
+        if (waitKey(1000) > 0)
+            break;
+
+        if (!outputVideoName.empty())
+        {
+            if (!writer.isOpened())
+                writer.open(outputVideoName, CV_FOURCC('X', 'V', 'I', 'D'), 25.0, result.size());
+            writer << result;
+        }
+    }
+
+    return 0;
+}