Merge branch 'master' of https://github.com/Itseez/opencv

3rdparty/libjpeg/CMakeLists.txt

@@ -9,7 +9,7 @@ ocv_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 file(GLOB lib_srcs *.c)
 file(GLOB lib_hdrs *.h)
 
-if(ANDROID OR IOS)
+if(ANDROID OR IOS OR APPLE)
   ocv_list_filterout(lib_srcs jmemansi.c)
 else()
   ocv_list_filterout(lib_srcs jmemnobs.c)

3rdparty/readme.txt

@@ -1,5 +1,5 @@
 This folder contains libraries and headers of a few very popular still image codecs
-used by highgui module.
+used by imgcodecs module.
 The libraries and headers are preferably to build Win32 and Win64 versions of OpenCV.
 On UNIX systems all the libraries are automatically detected by configure script.
 In order to use these versions of libraries instead of system ones on UNIX systems you
@@ -11,7 +11,7 @@ libjpeg 8d (8.4)  -   The Independent JPEG Group's JPEG software.
                       See IGJ home page http://www.ijg.org
                       for details and links to the source code
 
-                      HAVE_JPEG preprocessor flag must be set to make highgui use libjpeg.
+                      HAVE_JPEG preprocessor flag must be set to make imgcodecs use libjpeg.
                       On UNIX systems configure script takes care of it.
 ------------------------------------------------------------------------------------
 libpng 1.5.12     -   Portable Network Graphics library.
@@ -19,7 +19,7 @@ libpng 1.5.12     -   Portable Network Graphics library.
                       See libpng home page http://www.libpng.org
                       for details and links to the source code
 
-                      HAVE_PNG preprocessor flag must be set to make highgui use libpng.
+                      HAVE_PNG preprocessor flag must be set to make imgcodecs use libpng.
                       On UNIX systems configure script takes care of it.
 ------------------------------------------------------------------------------------
 libtiff 4.0.2     -   Tag Image File Format (TIFF) Software
@@ -28,7 +28,7 @@ libtiff 4.0.2     -   Tag Image File Format (TIFF) Software
                       See libtiff home page http://www.remotesensing.org/libtiff/
                       for details and links to the source code
 
-                      HAVE_TIFF preprocessor flag must be set to make highgui use libtiff.
+                      HAVE_TIFF preprocessor flag must be set to make imgcodecs use libtiff.
                       On UNIX systems configure script takes care of it.
                       In this build support for ZIP (LZ77 compression) is turned on.
 ------------------------------------------------------------------------------------
@@ -37,7 +37,7 @@ zlib 1.2.7        -   General purpose LZ77 compression library
                       See zlib home page http://www.zlib.net
                       for details and links to the source code
 
-                      No preprocessor definition is needed to make highgui use this library -
+                      No preprocessor definition is needed to make imgcodecs use this library -
                       it is included automatically if either libpng or libtiff are used.
 ------------------------------------------------------------------------------------
 jasper-1.900.1    -   JasPer is a collection of software

CMakeLists.txt

@@ -6,6 +6,8 @@
 #
 # ----------------------------------------------------------------------------
 
+
+
 include(cmake/OpenCVMinDepVersions.cmake)
 
 if(CMAKE_GENERATOR MATCHES Xcode AND XCODE_VERSION VERSION_GREATER 4.3)
@@ -135,6 +137,7 @@ OCV_OPTION(WITH_WEBP           "Include WebP support"                        ON
 OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS) )
 OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID) )
 OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_OPENNI2        "Include OpenNI2 support"                     OFF  IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_PNG            "Include PNG support"                         ON)
 OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_GIGEAPI        "Include Smartek GigE support"                ON   IF (NOT ANDROID AND NOT IOS) )
@@ -148,8 +151,8 @@ OCV_OPTION(WITH_TIFF           "Include TIFF support"                        ON
 OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT ANDROID) )
 OCV_OPTION(WITH_LIBV4L         "Use libv4l for Video 4 Linux support"        ON   IF (UNIX AND NOT ANDROID) )
-OCV_OPTION(WITH_DSHOW          "Build HighGUI with DirectShow support"       ON   IF (WIN32 AND NOT ARM) )
+OCV_OPTION(WITH_DSHOW          "Build VideoIO with DirectShow support"       ON   IF (WIN32 AND NOT ARM) )
-OCV_OPTION(WITH_MSMF           "Build HighGUI with Media Foundation support" OFF  IF WIN32 )
+OCV_OPTION(WITH_MSMF           "Build VideoIO with Media Foundation support" OFF  IF WIN32 )
 OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
 OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_CLP            "Include Clp support (EPL)"                   OFF)
@@ -865,6 +868,11 @@ if(DEFINED WITH_OPENNI)
                                                    THEN "YES (${OPENNI_PRIME_SENSOR_MODULE})"      ELSE NO)
 endif(DEFINED WITH_OPENNI)
 
+if(DEFINED WITH_OPENNI2)
+  status("    OpenNI2:"		   HAVE_OPENNI2	   THEN "YES (ver ${OPENNI2_VERSION_STRING}, build ${OPENNI2_VERSION_BUILD})"
+																								   ELSE NO)
+endif(DEFINED WITH_OPENNI2)
+
 if(DEFINED WITH_PVAPI)
   status("    PvAPI:"          HAVE_PVAPI          THEN YES                                        ELSE NO)
 endif(DEFINED WITH_PVAPI)

apps/traincascade/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_ml opencv_imgproc opencv_photo opencv_objdetect opencv_highgui opencv_calib3d opencv_video opencv_features2d)
+set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_ml opencv_imgproc opencv_photo opencv_objdetect opencv_imgcodecs opencv_videoio opencv_highgui opencv_calib3d opencv_video opencv_features2d)
 ocv_check_dependencies(${OPENCV_TRAINCASCADE_DEPS})
 
 if(NOT OCV_DEPENDENCIES_FOUND)

apps/traincascade/imagestorage.cpp

@@ -1,6 +1,7 @@
 #include "opencv2/core.hpp"
+#include "opencv2/core/core_c.h"
 #include "opencv2/imgproc.hpp"
-#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
 
 #include "imagestorage.h"
 #include <stdio.h>

apps/traincascade/imagestorage.h

@@ -1,9 +1,6 @@
 #ifndef _OPENCV_IMAGESTORAGE_H_
 #define _OPENCV_IMAGESTORAGE_H_
 
-#include "highgui.h"
-
-
 
 class CvCascadeImageReader
 {

cmake/OpenCVConfig.cmake

@@ -11,7 +11,7 @@
 #
 #    Or you can search for specific OpenCV modules:
 #
-#    FIND_PACKAGE(OpenCV REQUIRED core highgui)
+#    FIND_PACKAGE(OpenCV REQUIRED core imgcodecs)
 #
 #    If the module is found then OPENCV_<MODULE>_FOUND is set to TRUE.
 #

cmake/OpenCVFindLibsVideo.cmake

@@ -131,7 +131,7 @@ if(WITH_1394)
       if(HAVE_DC1394_2)
         ocv_parse_pkg("libdc1394-2" "${DC1394_2_LIB_DIR}/pkgconfig" "")
         ocv_include_directories(${DC1394_2_INCLUDE_PATH})
-        set(HIGHGUI_LIBRARIES ${HIGHGUI_LIBRARIES}
+        set(VIDEOIO_LIBRARIES ${VIDEOIO_LIBRARIES}
             "${DC1394_2_LIB_DIR}/libdc1394.a"
             "${CMU1394_LIB_DIR}/lib1394camera.a")
       endif(HAVE_DC1394_2)
@@ -166,6 +166,11 @@ if(WITH_OPENNI)
   include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindOpenNI.cmake")
 endif(WITH_OPENNI)
 
+ocv_clear_vars(HAVE_OPENNI2)
+if(WITH_OPENNI2)
+  include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindOpenNI2.cmake")
+endif(WITH_OPENNI2)
+
 # --- XIMEA ---
 ocv_clear_vars(HAVE_XIMEA)
 if(WITH_XIMEA)
@@ -234,7 +239,7 @@ if(WITH_FFMPEG)
       endif()
     endif(FFMPEG_INCLUDE_DIR)
     if(HAVE_FFMPEG)
-      set(HIGHGUI_LIBRARIES ${HIGHGUI_LIBRARIES} "${FFMPEG_LIB_DIR}/libavcodec.a"
+      set(VIDEOIO_LIBRARIES ${VIDEOIO_LIBRARIES} "${FFMPEG_LIB_DIR}/libavcodec.a"
           "${FFMPEG_LIB_DIR}/libavformat.a" "${FFMPEG_LIB_DIR}/libavutil.a"
           "${FFMPEG_LIB_DIR}/libswscale.a")
       ocv_include_directories(${FFMPEG_INCLUDE_DIR})
@@ -253,14 +258,15 @@ if(WITH_MSMF)
   check_include_file(Mfapi.h HAVE_MSMF)
 endif(WITH_MSMF)
 
-# --- Extra HighGUI libs on Windows ---
+# --- Extra HighGUI and VideoIO libs on Windows ---
 if(WIN32)
-  list(APPEND HIGHGUI_LIBRARIES comctl32 gdi32 ole32 setupapi ws2_32 vfw32)
+  list(APPEND HIGHGUI_LIBRARIES comctl32 gdi32 ole32 setupapi ws2_32)
+  list(APPEND VIDEOIO_LIBRARIES vfw32)
   if(MINGW64)
-    list(APPEND HIGHGUI_LIBRARIES avifil32 avicap32 winmm msvfw32)
+    list(APPEND VIDEOIO_LIBRARIES avifil32 avicap32 winmm msvfw32)
-    list(REMOVE_ITEM HIGHGUI_LIBRARIES vfw32)
+    list(REMOVE_ITEM VIDEOIO_LIBRARIES vfw32)
   elseif(MINGW)
-    list(APPEND HIGHGUI_LIBRARIES winmm)
+    list(APPEND VIDEOIO_LIBRARIES winmm)
   endif()
 endif(WIN32)
 

cmake/OpenCVFindOpenNI2.cmake

@@ -0,0 +1,61 @@
+# Main variables:
+# OPENNI2_LIBRARY and OPENNI2_INCLUDES to link OpenCV modules with OpenNI2
+# HAVE_OPENNI2 for conditional compilation OpenCV with/without OpenNI2
+
+if(NOT "${OPENNI2_LIB_DIR}" STREQUAL "${OPENNI2_LIB_DIR_INTERNAL}")
+    unset(OPENNI2_LIBRARY CACHE)
+    unset(OPENNI2_LIB_DIR CACHE)
+endif()
+
+if(NOT "${OPENNI2_INCLUDE_DIR}" STREQUAL "${OPENNI2_INCLUDE_DIR_INTERNAL}")
+    unset(OPENNI2_INCLUDES CACHE)
+    unset(OPENNI2_INCLUDE_DIR CACHE)
+endif()
+
+if(WIN32)
+    if(NOT (MSVC64 OR MINGW64))
+        find_file(OPENNI2_INCLUDES "OpenNI.h" PATHS "$ENV{OPEN_NI_INSTALL_PATH}Include" DOC "OpenNI2 c++ interface header")
+        find_library(OPENNI2_LIBRARY "OpenNI2" PATHS $ENV{OPENNI2_LIB} DOC "OpenNI2 library")
+    else()
+        find_file(OPENNI2_INCLUDES "OpenNI.h" PATHS "$ENV{OPEN_NI_INSTALL_PATH64}Include" DOC "OpenNI2 c++ interface header")
+        find_library(OPENNI2_LIBRARY "OpenNI2" PATHS $ENV{OPENNI2_LIB64} DOC "OpenNI2 library")
+    endif()
+elseif(UNIX OR APPLE)
+    find_file(OPENNI_INCLUDES "OpenNI.h" PATHS "/usr/include/ni2" "/usr/include/openni2" DOC "OpenNI2 c++ interface header")
+    find_library(OPENNI_LIBRARY "OpenNI2" PATHS "/usr/lib" DOC "OpenNI2 library")
+endif()
+
+if(OPENNI2_LIBRARY AND OPENNI2_INCLUDES)
+    set(HAVE_OPENNI2 TRUE)
+endif() #if(OPENNI_LIBRARY AND OPENNI_INCLUDES)
+
+get_filename_component(OPENNI2_LIB_DIR "${OPENNI2_LIBRARY}" PATH)
+get_filename_component(OPENNI2_INCLUDE_DIR ${OPENNI2_INCLUDES} PATH)
+
+if(HAVE_OPENNI2)
+  set(OPENNI2_LIB_DIR "${OPENNI2_LIB_DIR}" CACHE PATH "Path to OpenNI2 libraries" FORCE)
+  set(OPENNI2_INCLUDE_DIR "${OPENNI2_INCLUDE_DIR}" CACHE PATH "Path to OpenNI2 headers" FORCE)
+endif()
+
+if(OPENNI2_LIBRARY)
+    set(OPENNI2_LIB_DIR_INTERNAL "${OPENNI2_LIB_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI_LIB_DIR was set successfully." FORCE)
+else()
+    message( WARNING, " OpenNI2 library directory (set by OPENNI2_LIB_DIR variable) is not found or does not have OpenNI2 libraries." )
+endif()
+
+if(OPENNI2_INCLUDES)
+    set(OPENNI2_INCLUDE_DIR_INTERNAL "${OPENNI2_INCLUDE_DIR}" CACHE INTERNAL "This is the value of the last time OPENNI2_INCLUDE_DIR was set successfully." FORCE)
+else()
+    message( WARNING, " OpenNI2 include directory (set by OPENNI2_INCLUDE_DIR variable) is not found or does not have OpenNI2 include files." )
+endif()
+
+mark_as_advanced(FORCE OPENNI2_LIBRARY)
+mark_as_advanced(FORCE OPENNI2_INCLUDES)
+
+if(HAVE_OPENNI2)
+  ocv_parse_header("${OPENNI2_INCLUDE_DIR}/OniVersion.h" ONI_VERSION_LINE ONI_VERSION_MAJOR ONI_VERSION_MINOR ONI_VERSION_MAINTENANCE ONI_VERSION_BUILD)
+  if(ONI_VERSION_MAJOR)
+    set(OPENNI2_VERSION_STRING ${ONI_VERSION_MAJOR}.${ONI_VERSION_MINOR}.${ONI_VERSION_MAINTENANCE} CACHE INTERNAL "OpenNI2 version")
+    set(OPENNI2_VERSION_BUILD ${ONI_VERSION_BUILD} CACHE INTERNAL "OpenNI2 build version")
+  endif()
+endif()

cmake/OpenCVGenInfoPlist.cmake

@@ -1,4 +1,7 @@
 if(IOS)
   configure_file("${OpenCV_SOURCE_DIR}/platforms/ios/Info.plist.in"
                  "${CMAKE_BINARY_DIR}/ios/Info.plist")
+elseif(APPLE)
+  configure_file("${OpenCV_SOURCE_DIR}/platforms/osx/Info.plist.in"
+                 "${CMAKE_BINARY_DIR}/osx/Info.plist")
 endif()

cmake/OpenCVModule.cmake

@@ -704,8 +704,8 @@ function(ocv_add_perf_tests)
   if(BUILD_PERF_TESTS AND EXISTS "${perf_path}")
     __ocv_parse_test_sources(PERF ${ARGN})
 
-    # opencv_highgui is required for imread/imwrite
+    # opencv_imgcodecs is required for imread/imwrite
-    set(perf_deps ${the_module} opencv_ts opencv_highgui ${OPENCV_PERF_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
+    set(perf_deps ${the_module} opencv_ts opencv_imgcodecs ${OPENCV_PERF_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
     ocv_check_dependencies(${perf_deps})
 
     if(OCV_DEPENDENCIES_FOUND)
@@ -757,8 +757,8 @@ function(ocv_add_accuracy_tests)
   if(BUILD_TESTS AND EXISTS "${test_path}")
     __ocv_parse_test_sources(TEST ${ARGN})
 
-    # opencv_highgui is required for imread/imwrite
+    # opencv_imgcodecs is required for imread/imwrite
-    set(test_deps ${the_module} opencv_ts opencv_highgui ${OPENCV_TEST_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
+    set(test_deps ${the_module} opencv_ts opencv_imgcodecs opencv_videoio ${OPENCV_TEST_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
     ocv_check_dependencies(${test_deps})
 
     if(OCV_DEPENDENCIES_FOUND)
@@ -811,7 +811,7 @@ function(ocv_add_samples)
   string(REGEX REPLACE "^opencv_" "" module_id ${the_module})
 
   if(BUILD_EXAMPLES AND EXISTS "${samples_path}")
-    set(samples_deps ${the_module} ${OPENCV_MODULE_${the_module}_DEPS} opencv_highgui ${ARGN})
+    set(samples_deps ${the_module} ${OPENCV_MODULE_${the_module}_DEPS} opencv_imgcodecs opencv_videoio opencv_highgui ${ARGN})
     ocv_check_dependencies(${samples_deps})
 
     if(OCV_DEPENDENCIES_FOUND)

cmake/OpenCVUtils.cmake

@@ -265,16 +265,19 @@ macro(CHECK_MODULE module_name define)
       set(${define} 1)
       foreach(P "${ALIAS_INCLUDE_DIRS}")
         if(${P})
+          list(APPEND VIDEOIO_INCLUDE_DIRS ${${P}})
           list(APPEND HIGHGUI_INCLUDE_DIRS ${${P}})
         endif()
       endforeach()
 
       foreach(P "${ALIAS_LIBRARY_DIRS}")
         if(${P})
+          list(APPEND VIDEOIO_LIBRARY_DIRS ${${P}})
           list(APPEND HIGHGUI_LIBRARY_DIRS ${${P}})
         endif()
       endforeach()
 
+      list(APPEND VIDEOIO_LIBRARIES ${${ALIAS_LIBRARIES}})
       list(APPEND HIGHGUI_LIBRARIES ${${ALIAS_LIBRARIES}})
     endif()
   endif()

cmake/templates/OpenCVConfig.cmake.in

@@ -12,7 +12,7 @@
 #
 #    Or you can search for specific OpenCV modules:
 #
-#    find_package(OpenCV REQUIRED core highgui)
+#    find_package(OpenCV REQUIRED core videoio)
 #
 #    If the module is found then OPENCV_<MODULE>_FOUND is set to TRUE.
 #

cmake/templates/cvconfig.h.in

@@ -129,6 +129,9 @@
 /* OpenNI library */
 #cmakedefine HAVE_OPENNI
 
+/* OpenNI library */
+#cmakedefine HAVE_OPENNI2
+
 /* PNG codec */
 #cmakedefine HAVE_PNG
 

doc/CMakeLists.txt

@@ -33,7 +33,7 @@ if(BUILD_DOCS AND HAVE_SPHINX)
     endif()
   endforeach()
 
-  set(FIXED_ORDER_MODULES core imgproc highgui video calib3d features2d objdetect ml flann photo stitching nonfree contrib legacy)
+  set(FIXED_ORDER_MODULES core imgproc imgcodecs videoio highgui video calib3d features2d objdetect ml flann photo stitching nonfree contrib legacy)
 
   list(REMOVE_ITEM BASE_MODULES ${FIXED_ORDER_MODULES})
 

doc/check_docs.py

@@ -14,6 +14,8 @@ opencv_hdr_list = [
 "../modules/video/include/opencv2/video/tracking.hpp",
 "../modules/video/include/opencv2/video/background_segm.hpp",
 "../modules/objdetect/include/opencv2/objdetect.hpp",
+"../modules/imgcodecs/include/opencv2/imgcodecs.hpp",
+"../modules/videoio/include/opencv2/videoio.hpp",
 "../modules/highgui/include/opencv2/highgui.hpp",
 ]
 
@@ -24,6 +26,8 @@ opencv_module_list = [
 "features2d",
 "video",
 "objdetect",
+"imgcodecs",
+"videoio",
 "highgui",
 "ml"
 ]

doc/conf.py

@@ -302,14 +302,16 @@ man_pages = [
 extlinks = {
             'basicstructures' : ('http://docs.opencv.org/modules/core/doc/basic_structures.html#%s', None),
             'oldbasicstructures' : ('http://docs.opencv.org/modules/core/doc/old_basic_structures.html#%s', None),
-            'readwriteimagevideo' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'readwriteimage' : ('http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html#%s', None),
+            'readwritevideo' : ('http://docs.opencv.org/modules/videoio/doc/reading_and_writing_video.html#%s', None),
             'operationsonarrays' : ('http://docs.opencv.org/modules/core/doc/operations_on_arrays.html#%s', None),
             'utilitysystemfunctions' : ('http://docs.opencv.org/modules/core/doc/utility_and_system_functions_and_macros.html#%s', None),
             'imgprocfilter' : ('http://docs.opencv.org/modules/imgproc/doc/filtering.html#%s', None),
             'svms' : ('http://docs.opencv.org/modules/ml/doc/support_vector_machines.html#%s', None),
             'drawingfunc' : ('http://docs.opencv.org/modules/core/doc/drawing_functions.html#%s', None),
             'xmlymlpers' : ('http://docs.opencv.org/modules/core/doc/xml_yaml_persistence.html#%s', None),
-            'hgvideo' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None),
+            'rwimg' : ('http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html#%s', None),
+            'hgvideo' : ('http://docs.opencv.org/modules/videoio/doc/reading_and_writing_video.html#%s', None),
             'gpuinit' : ('http://docs.opencv.org/modules/gpu/doc/initalization_and_information.html#%s', None),
             'gpudatastructure' : ('http://docs.opencv.org/modules/gpu/doc/data_structures.html#%s', None),
             'gpuopmatrices' : ('http://docs.opencv.org/modules/gpu/doc/operations_on_matrices.html#%s', None),
@@ -329,8 +331,8 @@ extlinks = {
             'how_to_contribute' : ('http://code.opencv.org/projects/opencv/wiki/How_to_contribute/%s', None),
 
             'cvt_color' : ('http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html?highlight=cvtcolor#cvtcolor%s', None),
-            'imread' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imread#imread%s', None),
+            'imread' : ('http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html?highlight=imread#imread%s', None),
-            'imwrite' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=imwrite#imwrite%s', None),
+            'imwrite' : ('http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html?highlight=imwrite#imwrite%s', None),
             'imshow' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=imshow#imshow%s', None),
             'named_window' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=namedwindow#namedwindow%s', None),
             'wait_key' : ('http://docs.opencv.org/modules/highgui/doc/user_interface.html?highlight=waitkey#waitkey%s', None),
@@ -418,7 +420,7 @@ extlinks = {
             'background_subtractor' : ('http://docs.opencv.org/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractor#backgroundsubtractor%s', None),
             'background_subtractor_mog' : ('http://docs.opencv.org/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractorMOG#backgroundsubtractormog%s', None),
             'background_subtractor_mog_two' : ('http://docs.opencv.org/modules/video/doc/motion_analysis_and_object_tracking.html?highlight=backgroundsubtractorMOG2#backgroundsubtractormog2%s', None),
-            'video_capture' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html?highlight=videocapture#videocapture%s', None),
+            'video_capture' : ('http://docs.opencv.org/modules/videoio/doc/reading_and_writing_video.html?highlight=videocapture#videocapture%s', None),
             'ippa_convert': ('http://docs.opencv.org/modules/core/doc/ipp_async_converters.html#%s', None),
             'ptr':('http://docs.opencv.org/modules/core/doc/basic_structures.html?highlight=Ptr#Ptr%s', None)
            }

doc/opencv_cheatsheet.tex

@@ -522,9 +522,9 @@ samples on what are the contours and how to use them.
 
 \begin{tabbing}
 \textbf{Wr}\=\textbf{iting and reading raster images}\\
-\texttt{\href{http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html\#imwrite}{imwrite}("myimage.jpg", image);}\\
+\texttt{\href{http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html\#imwrite}{imwrite}("myimage.jpg", image);}\\
-\texttt{Mat image\_color\_copy = \href{http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html\#imread}{imread}("myimage.jpg", 1);}\\
+\texttt{Mat image\_color\_copy = \href{http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html\#imread}{imread}("myimage.jpg", 1);}\\
-\texttt{Mat image\_grayscale\_copy = \href{http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html\#imread}{imread}("myimage.jpg", 0);}\\
+\texttt{Mat image\_grayscale\_copy = \href{http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html\#imread}{imread}("myimage.jpg", 0);}\\
 \end{tabbing}
 
 \emph{The functions can read/write images in the following formats: \textbf{BMP (.bmp), JPEG (.jpg, .jpeg), TIFF (.tif, .tiff), PNG (.png), PBM/PGM/PPM (.p?m), Sun Raster (.sr), JPEG 2000 (.jp2)}. Every format supports 8-bit, 1- or 3-channel images. Some formats (PNG, JPEG 2000) support 16 bits per channel.}

doc/py_tutorials/py_gui/py_video_display/py_video_display.rst

@@ -46,7 +46,7 @@ To capture a video, you need to create a **VideoCapture** object. Its argument c
 
 Sometimes, ``cap`` may not have initialized the capture. In that case, this code shows error. You can check whether it is initialized or not by the method **cap.isOpened()**. If it is True, OK. Otherwise open it using **cap.open()**.
 
-You can also access some of the features of this video using **cap.get(propId)** method where propId is a number from 0 to 18. Each number denotes a property of the video (if it is applicable to that video) and full details can be seen here: `Property Identifier <http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#videocapture-get>`_. Some of these values can be modified using **cap.set(propId, value)**. Value is the new value you want.
+You can also access some of the features of this video using **cap.get(propId)** method where propId is a number from 0 to 18. Each number denotes a property of the video (if it is applicable to that video) and full details can be seen here: `Property Identifier <http://docs.opencv.org/modules/highgui/doc/reading_and_writing_video.html#videocapture-get>`_. Some of these values can be modified using **cap.set(propId, value)**. Value is the new value you want.
 
 For example, I can check the frame width and height by ``cap.get(3)`` and ``cap.get(4)``. It gives me 640x480 by default. But I want to modify it to 320x240. Just use ``ret = cap.set(3,320)`` and ``ret = cap.set(4,240)``.
 

doc/tutorials/core/discrete_fourier_transform/discrete_fourier_transform.rst

@@ -25,7 +25,7 @@ Here's a sample usage of :operationsonarrays:`dft() <dft>` :
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 1-3, 5, 19-20, 23-78
+   :lines: 1-4, 6, 20-21, 24-79
 
 Explanation
 ===========

doc/tutorials/core/how_to_scan_images/how_to_scan_images.rst

@@ -45,7 +45,7 @@ The final argument is optional. If given the image will be loaded in gray scale
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 48-60
+   :lines: 49-61
 
 Here we first use the C++ *stringstream* class to convert the third command line argument from text to an integer format. Then we use a simple look and the upper formula to calculate the lookup table. No OpenCV specific stuff here.
 
@@ -99,7 +99,7 @@ When it comes to performance you cannot beat the classic C style operator[] (poi
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 125-152
+   :lines: 126-153
 
 Here we basically just acquire a pointer to the start of each row and go through it until it ends. In the special case that the matrix is stored in a continues manner we only need to request the pointer a single time and go all the way to the end. We need to look out for color images: we have three channels so we need to pass through three times more items in each row.
 
@@ -122,7 +122,7 @@ In case of the efficient way making sure that you pass through the right amount
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 154-182
+   :lines: 155-183
 
 In case of color images we have three uchar items per column. This may be considered a short vector of uchar items, that has been baptized in OpenCV with the *Vec3b* name. To access the n-th sub column we use simple operator[] access. It's important to remember that OpenCV iterators go through the columns and automatically skip to the next row. Therefore in case of color images if you use a simple *uchar* iterator you'll be able to access only the blue channel values.
 
@@ -134,7 +134,7 @@ The final method isn't recommended for scanning. It was made to acquire or modif
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 184-216
+   :lines: 185-217
 
 The functions takes your input type and coordinates and calculates on the fly the address of the queried item. Then returns a reference to that. This may be a constant when you *get* the value and non-constant when you *set* the value. As a safety step in **debug mode only*** there is performed a check that your input coordinates are valid and does exist. If this isn't the case you'll get a nice output message of this on the standard error output stream. Compared to the efficient way in release mode the only difference in using this is that for every element of the image you'll get a new row pointer for what we use the C operator[] to acquire the column element.
 
@@ -148,14 +148,14 @@ This is a bonus method of achieving lookup table modification in an image. Becau
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 107-110
+   :lines: 108-111
 
 Finally call the function (I is our input image and J the output one):
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 115
+   :lines: 116
 
 Performance Difference
 ======================

doc/tutorials/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.rst

@@ -77,7 +77,7 @@ Now that you have the basics done :download:`here's <../../../../samples/cpp/tut
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 1-9, 22-25, 27-44
+   :lines: 1-10, 23-26, 29-46
 
 Here you can observe that with the new structure we have no pointer problems, although it is possible to use the old functions and in the end just transform the result to a *Mat* object.
 
@@ -85,7 +85,7 @@ Here you can observe that with the new structure we have no pointer problems, al
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 46-51
+   :lines: 48-53
 
 Because, we want to mess around with the images luma component we first convert from the default RGB to the YUV color space and then split the result up into separate planes. Here the program splits: in the first example it processes each plane using one of the three major image scanning algorithms in OpenCV (C [] operator, iterator, individual element access). In a second variant we add to the image some Gaussian noise and then mix together the channels according to some formula.
 
@@ -95,7 +95,7 @@ The scanning version looks like:
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 55-75
+   :lines: 57-77
 
 Here you can observe that we may go through all the pixels of an image in three fashions: an iterator, a C pointer and an individual element access style. You can read a more in-depth description of these in the :ref:`howToScanImagesOpenCV` tutorial. Converting from the old function names is easy. Just remove the cv prefix and use the new *Mat* data structure. Here's an example of this by using the weighted addition function:
 
@@ -103,7 +103,7 @@ Here you can observe that we may go through all the pixels of an image in three
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 79-112
+   :lines: 81-113
 
 As you may observe the *planes* variable is of type *Mat*. However, converting from *Mat* to *IplImage* is easy and made automatically with a simple assignment operator.
 
@@ -111,7 +111,7 @@ As you may observe the *planes* variable is of type *Mat*. However, converting f
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 115-127
+   :lines: 117-129
 
 The new *imshow* highgui function accepts both the *Mat* and *IplImage* data structures. Compile and run the program and if the first image below is your input you may get either the first or second as output:
 

doc/tutorials/core/mat_the_basic_image_container/mat_the_basic_image_container.rst

@@ -86,7 +86,7 @@ Each of the building components has their own valid domains. This leads to the d
 Creating a *Mat* object explicitly
 ==================================
 
-In the :ref:`Load_Save_Image` tutorial you have already learned how to write a matrix to an image file by using the :readwriteimagevideo:`imwrite() <imwrite>` function. However, for debugging purposes it's much more convenient to see the actual values. You can do this using the << operator of *Mat*. Be aware that this only works for two dimensional matrices.
+In the :ref:`Load_Save_Image` tutorial you have already learned how to write a matrix to an image file by using the :readwriteimage:`imwrite() <imwrite>` function. However, for debugging purposes it's much more convenient to see the actual values. You can do this using the << operator of *Mat*. Be aware that this only works for two dimensional matrices.
 
 Although *Mat* works really well as an image container, it is also a general matrix class. Therefore, it is possible to create and manipulate multidimensional matrices. You can create a Mat object in multiple ways:
 

doc/tutorials/core/table_of_content_core/table_of_content_core.rst

@@ -200,7 +200,6 @@ Here you will learn the about the basic building blocks of the library. A must r
                    :height: 90pt
                    :width:  90pt
 
-  =============== ======================================================
 +
   .. tabularcolumns:: m{100pt} m{300pt}
   .. cssclass:: toctableopencv
@@ -221,8 +220,6 @@ Here you will learn the about the basic building blocks of the library. A must r
                    :width:  90pt
   .. |Author_ElenaG| unicode:: Elena U+0020 Gvozdeva
 
-  =============== ======================================================
-
 .. raw:: latex
 
    \pagebreak

doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.rst

@@ -22,7 +22,7 @@ As a test case where to show off these using OpenCV I've created a small program
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 1-14, 28-29, 31-205
+   :lines: 1-15, 29-31, 33-208
 
 How to read a video stream (online-camera or offline-file)?
 ===========================================================

doc/tutorials/introduction/clojure_dev_intro/clojure_dev_intro.rst

@@ -656,7 +656,7 @@ classes we're going to use:
      Results: Stored in vars *1, *2, *3, an exception in *e
 
     user=> (import '[org.opencv.core Mat Size CvType]
-                   '[org.opencv.highgui Highgui]
+                   '[org.opencv.imgcodecs Imgcodecs]
                    '[org.opencv.imgproc Imgproc])
     org.opencv.imgproc.Imgproc
 

doc/tutorials/introduction/desktop_java/java_dev_intro.rst

@@ -373,7 +373,7 @@ Now modify src/main/java/HelloOpenCV.java so it contains the following Java code
    import org.opencv.core.Point;
    import org.opencv.core.Rect;
    import org.opencv.core.Scalar;
-   import org.opencv.highgui.Highgui;
+   import org.opencv.imgcodecs.Imgcodecs;
    import org.opencv.objdetect.CascadeClassifier;
 
    //
@@ -387,7 +387,7 @@ Now modify src/main/java/HelloOpenCV.java so it contains the following Java code
        // Create a face detector from the cascade file in the resources
        // directory.
        CascadeClassifier faceDetector = new CascadeClassifier(getClass().getResource("/lbpcascade_frontalface.xml").getPath());
-       Mat image = Highgui.imread(getClass().getResource("/lena.png").getPath());
+       Mat image = Imgcodecs.imread(getClass().getResource("/lena.png").getPath());
 
        // Detect faces in the image.
        // MatOfRect is a special container class for Rect.
@@ -404,7 +404,7 @@ Now modify src/main/java/HelloOpenCV.java so it contains the following Java code
        // Save the visualized detection.
        String filename = "faceDetection.png";
        System.out.println(String.format("Writing %s", filename));
-       Highgui.imwrite(filename, image);
+       Imgcodecs.imwrite(filename, image);
      }
    }
 

doc/tutorials/introduction/display_image/display_image.rst

@@ -39,28 +39,28 @@ You'll almost always end up using the:
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
    :tab-width: 4
-   :lines:  1-3
+   :lines:  1-4
 
 We also include the *iostream* to facilitate console line output and input. To avoid data structure and function name conflicts with other libraries, OpenCV has its own namespace: *cv*. To avoid the need appending prior each of these the *cv::* keyword you can import the namespace in the whole file by using the lines:
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
    :tab-width: 4
-   :lines:  5-6
+   :lines:  6-7
 
 This is true for the STL library too (used for console I/O). Now, let's analyze the *main* function. We start up assuring that we acquire a valid image name argument from the command line.
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 10-14
+   :lines: 11-15
 
 Then create a *Mat* object that will store the data of the loaded image.
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 16
+   :lines: 17
 
 Now we call the :imread:`imread <>` function which loads the image name specified by the first argument (*argv[1]*). The second argument specifies the format in what we want the image. This may be:
 
@@ -73,7 +73,7 @@ Now we call the :imread:`imread <>` function which loads the image name specifie
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
    :tab-width: 4
-   :lines: 17
+   :lines: 18
 
 .. note::
 
@@ -88,21 +88,21 @@ After checking that the image data was loaded correctly, we want to display our
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
-   :lines: 25
+   :lines: 26
    :tab-width: 4
 
 Finally, to update the content of the OpenCV window with a new image use the :imshow:`imshow <>` function. Specify the OpenCV window name to update and the image to use during this operation:
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
-   :lines: 26
+   :lines: 27
    :tab-width: 4
 
 Because we want our window to be displayed until the user presses a key (otherwise the program would end far too quickly), we use the :wait_key:`waitKey <>` function whose only parameter is just how long should it wait for a user input (measured in milliseconds). Zero means to wait forever.
 
 .. literalinclude:: ../../../../samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
    :language: cpp
-   :lines: 28
+   :lines: 29
    :tab-width: 4
 
 Result

doc/tutorials/introduction/how_to_write_a_tutorial/how_to_write_a_tutorial.rst

@@ -349,7 +349,7 @@ Now here's our recommendation for the structure of the tutorial (although, remem
            :language: cpp
            :linenos:
            :tab-width: 4
-           :lines: 1-8, 21-22, 24-
+           :lines: 1-8, 21-23, 25-
 
      After the directive you specify a relative path to the file from what to import. It has four options: the language to use, if you add the ``:linenos:`` the line numbers will be shown, you can specify the tab size with the ``:tab-width:`` and you do not need to load the whole file, you can show just the important lines. Use the *lines* option to do not show redundant information (such as the *help* function). Here basically you specify ranges, if the second range line number is missing than that means that until the end of the file. The ranges specified here do no need to be in an ascending order, you may even reorganize the structure of how you want to show your sample inside the tutorial.
 
@@ -361,16 +361,16 @@ Now here's our recommendation for the structure of the tutorial (although, remem
 
        # ---- External links for tutorials -----------------
        extlinks = {
-           'hgvideo' : ('http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#%s', None)
+           'rwimg' : ('http://docs.opencv.org/modules/imgcodecs/doc/reading_and_writing_images.html#%s', None)
            }
 
-     In short here we defined a new **hgvideo** directive that refers to an external webpage link. Its usage is:
+     In short here we defined a new **rwimg** directive that refers to an external webpage link. Its usage is:
 
      .. code-block:: rst
 
-       A sample function of the highgui modules image write and read page is the :hgvideo:`imread() function <imread>`.
+       A sample function of the highgui modules image write and read page is the :rwimg:`imread() function <imread>`.
 
-     Which turns to: A sample function of the highgui modules image write and read page is the :hgvideo:`imread() function <imread>`. The argument you give between the <> will be put in place of the ``%s`` in the upper definition, and as the link will anchor to the correct function. To find out the anchor of a given function just open up a web page, search for the function and click on it. In the address bar it should appear like: ``http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#imread`` .  Look here for the name of the directives for each page of the OpenCV reference manual. If none present for one of them feel free to add one for it.
+     Which turns to: A sample function of the highgui modules image write and read page is the :rwimg:`imread() function <imread>`. The argument you give between the <> will be put in place of the ``%s`` in the upper definition, and as the link will anchor to the correct function. To find out the anchor of a given function just open up a web page, search for the function and click on it. In the address bar it should appear like: ``http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images.html#imread`` .  Look here for the name of the directives for each page of the OpenCV reference manual. If none present for one of them feel free to add one for it.
 
      For formulas you can add LATEX code that will translate in the web pages into images. You do this by using the *math* directive. A usage tip:
 

doc/tutorials/introduction/load_save_image/load_save_image.rst

@@ -5,7 +5,7 @@ Load, Modify, and Save an Image
 
 .. note::
 
-   We assume that by now you know how to load an image using :readwriteimagevideo:`imread <imread>` and to display it in a window (using :user_interface:`imshow <imshow>`). Read the :ref:`Display_Image` tutorial otherwise.
+   We assume that by now you know how to load an image using :readwriteimage:`imread <imread>` and to display it in a window (using :user_interface:`imshow <imshow>`). Read the :ref:`Display_Image` tutorial otherwise.
 
 Goals
 ======
@@ -14,9 +14,9 @@ In this tutorial you will learn how to:
 
 .. container:: enumeratevisibleitemswithsquare
 
-   * Load an image using :readwriteimagevideo:`imread <imread>`
+   * Load an image using :readwriteimage:`imread <imread>`
    * Transform an image from BGR to Grayscale format by using :miscellaneous_transformations:`cvtColor <cvtcolor>`
-   * Save your transformed image in a file on disk (using :readwriteimagevideo:`imwrite <imwrite>`)
+   * Save your transformed image in a file on disk (using :readwriteimage:`imwrite <imwrite>`)
 
 Code
 ======
@@ -62,7 +62,7 @@ Here it is:
 Explanation
 ============
 
-#. We begin by loading an image using :readwriteimagevideo:`imread <imread>`, located in the path given by *imageName*. For this example, assume you are loading a RGB image.
+#. We begin by loading an image using :readwriteimage:`imread <imread>`, located in the path given by *imageName*. For this example, assume you are loading a RGB image.
 
 #. Now we are going to convert our image from BGR to Grayscale format. OpenCV has a really nice function to do this kind of transformations:
 
@@ -76,9 +76,9 @@ Explanation
 
       * a source image (*image*)
       * a destination image (*gray_image*), in which we will save the converted image.
-      * an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_BGR2GRAY** (because of :readwriteimagevideo:`imread <imread>` has BGR default channel order in case of color images).
+      * an additional parameter that indicates what kind of transformation will be performed. In this case we use **CV_BGR2GRAY** (because of :readwriteimage:`imread <imread>` has BGR default channel order in case of color images).
 
-#. So now we have our new *gray_image* and want to save it on disk (otherwise it will get lost after the program ends). To save it, we will use a function analagous to :readwriteimagevideo:`imread <imread>`: :readwriteimagevideo:`imwrite <imwrite>`
+#. So now we have our new *gray_image* and want to save it on disk (otherwise it will get lost after the program ends). To save it, we will use a function analagous to :readwriteimage:`imread <imread>`: :readwriteimage:`imwrite <imwrite>`
 
    .. code-block:: cpp
 

doc/tutorials/introduction/windows_visual_studio_image_watch/windows_visual_studio_image_watch.rst

@@ -32,7 +32,7 @@ Image Watch works with any existing project that uses OpenCV image objects (for
 
     #include <iostream>                        // std::cout
     #include <opencv2/core/core.hpp>           // cv::Mat
-    #include <opencv2/highgui/highgui.hpp>     // cv::imread()
+    #include <opencv2/imgcodecs/imgcodecs.hpp>     // cv::imread()
     #include <opencv2/imgproc/imgproc.hpp>     // cv::Canny()
 
     using namespace std;

doc/tutorials/ios/video_processing/video_processing.rst

@@ -80,7 +80,7 @@ We add a camera controller to the view controller and initialize it when the vie
 .. code-block:: objc
     :linenos:
 
-    #import <opencv2/highgui/cap_ios.h>
+    #import <opencv2/videoio/cap_ios.h>
     using namespace cv;
 
 

doc/tutorials/ml/non_linear_svms/non_linear_svms.rst

@@ -73,7 +73,7 @@ You may also find the source code and these video file in the :file:`samples/cpp
    :language: cpp
    :linenos:
    :tab-width: 4
-   :lines: 1-11, 22-23, 26-
+   :lines: 1-12, 23-24, 27-
 
 Explanation
 ===========

include/opencv2/opencv.hpp

@@ -50,6 +50,8 @@
 #include "opencv2/features2d.hpp"
 #include "opencv2/objdetect.hpp"
 #include "opencv2/calib3d.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
 #include "opencv2/highgui.hpp"
 #include "opencv2/ml.hpp"
 

modules/calib3d/perf/perf_precomp.hpp

@@ -11,7 +11,7 @@
 
 #include "opencv2/ts.hpp"
 #include "opencv2/calib3d.hpp"
-#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
 #include "opencv2/imgproc.hpp"
 
 #ifdef GTEST_CREATE_SHARED_LIBRARY

modules/calib3d/test/test_precomp.hpp

@@ -13,7 +13,7 @@
 #include "opencv2/ts.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/calib3d.hpp"
-#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
 
 namespace cvtest
 {

modules/core/doc/basic_structures.rst

@@ -2981,7 +2981,7 @@ The class provides the following features for all derived classes:
 
     * so called "virtual constructor". That is, each Algorithm derivative is registered at program start and you can get the list of registered algorithms and create instance of a particular algorithm by its name (see ``Algorithm::create``). If you plan to add your own algorithms, it is good practice to add a unique prefix to your algorithms to distinguish them from other algorithms.
 
-    * setting/retrieving algorithm parameters by name. If you used video capturing functionality from OpenCV highgui module, you are probably familar with ``cvSetCaptureProperty()``, ``cvGetCaptureProperty()``, ``VideoCapture::set()`` and ``VideoCapture::get()``. ``Algorithm`` provides similar method where instead of integer id's you specify the parameter names as text strings. See ``Algorithm::set`` and ``Algorithm::get`` for details.
+    * setting/retrieving algorithm parameters by name. If you used video capturing functionality from OpenCV videoio module, you are probably familar with ``cvSetCaptureProperty()``, ``cvGetCaptureProperty()``, ``VideoCapture::set()`` and ``VideoCapture::get()``. ``Algorithm`` provides similar method where instead of integer id's you specify the parameter names as text strings. See ``Algorithm::set`` and ``Algorithm::get`` for details.
 
     * reading and writing parameters from/to XML or YAML files. Every Algorithm derivative can store all its parameters and then read them back. There is no need to re-implement it each time.
 

modules/core/doc/drawing_functions.rst

@@ -361,6 +361,37 @@ The function ``line`` draws the line segment between ``pt1`` and ``pt2`` points
 Antialiased lines are drawn using Gaussian filtering.
 
 
+arrowedLine
+----------------
+Draws a arrow segment pointing from the first point to the second one.
+
+.. ocv:function:: void arrowedLine(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,          int thickness=1, int lineType=8, int shift=0, double tipLength=0.1)
+
+    :param img: Image.
+
+    :param pt1: The point the arrow starts from.
+
+    :param pt2: The point the arrow points to.
+
+    :param color: Line color.
+
+    :param thickness: Line thickness.
+
+    :param lineType: Type of the line:
+
+            * **8** (or omitted) - 8-connected line.
+
+            * **4** - 4-connected line.
+
+            * **CV_AA** - antialiased line.
+
+    :param shift: Number of fractional bits in the point coordinates.
+
+    :param tipLength: The length of the arrow tip in relation to the arrow length
+
+The function ``arrowedLine`` draws an arrow between ``pt1`` and ``pt2`` points in the image. See also :ocv:func:`line`.
+
+
 LineIterator
 ------------
 .. ocv:class:: LineIterator

modules/core/doc/intro.rst

@@ -14,7 +14,8 @@ OpenCV has a modular structure, which means that the package includes several sh
  * **calib3d** - basic multiple-view geometry algorithms, single and stereo camera calibration, object pose estimation, stereo correspondence algorithms, and elements of 3D reconstruction.
  * **features2d** - salient feature detectors, descriptors, and descriptor matchers.
  * **objdetect** - detection of objects and instances of the predefined classes (for example, faces, eyes, mugs, people, cars, and so on).
- * **highgui** - an easy-to-use interface to video capturing, image and video codecs, as well as simple UI capabilities.
+ * **highgui** - an easy-to-use interface to simple UI capabilities.
+ * **videoio** - an easy-to-use interface to video capturing and video codecs.
  * **gpu** - GPU-accelerated algorithms from different OpenCV modules.
  * ... some other helper modules, such as FLANN and Google test wrappers, Python bindings, and others.
 

modules/core/include/opencv2/core.hpp

@@ -510,6 +510,10 @@ CV_EXPORTS_W void randShuffle(InputOutputArray dst, double iterFactor = 1., RNG*
 CV_EXPORTS_W void line(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
                      int thickness = 1, int lineType = LINE_8, int shift = 0);
 
+//! draws an arrow from pt1 to pt2 in the image
+CV_EXPORTS_W void arrowedLine(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
+                     int thickness=1, int line_type=8, int shift=0, double tipLength=0.1);
+
 //! draws the rectangle outline or a solid rectangle with the opposite corners pt1 and pt2 in the image
 CV_EXPORTS_W void rectangle(InputOutputArray img, Point pt1, Point pt2,
                           const Scalar& color, int thickness = 1,

modules/core/include/opencv2/core/mat.hpp

@@ -360,7 +360,7 @@ struct CV_EXPORTS UMatData
 {
     enum { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
         DEVICE_COPY_OBSOLETE=4, TEMP_UMAT=8, TEMP_COPIED_UMAT=24,
-        USER_ALLOCATED=32 };
+        USER_ALLOCATED=32, DEVICE_MEM_MAPPED=64};
     UMatData(const MatAllocator* allocator);
     ~UMatData();
 
@@ -370,11 +370,13 @@ struct CV_EXPORTS UMatData
 
     bool hostCopyObsolete() const;
     bool deviceCopyObsolete() const;
+    bool deviceMemMapped() const;
     bool copyOnMap() const;
     bool tempUMat() const;
     bool tempCopiedUMat() const;
     void markHostCopyObsolete(bool flag);
     void markDeviceCopyObsolete(bool flag);
+    void markDeviceMemMapped(bool flag);
 
     const MatAllocator* prevAllocator;
     const MatAllocator* currAllocator;

modules/core/include/opencv2/core/mat.inl.hpp

@@ -3350,10 +3350,19 @@ size_t UMat::total() const
 
 inline bool UMatData::hostCopyObsolete() const { return (flags & HOST_COPY_OBSOLETE) != 0; }
 inline bool UMatData::deviceCopyObsolete() const { return (flags & DEVICE_COPY_OBSOLETE) != 0; }
+inline bool UMatData::deviceMemMapped() const { return (flags & DEVICE_MEM_MAPPED) != 0; }
 inline bool UMatData::copyOnMap() const { return (flags & COPY_ON_MAP) != 0; }
 inline bool UMatData::tempUMat() const { return (flags & TEMP_UMAT) != 0; }
 inline bool UMatData::tempCopiedUMat() const { return (flags & TEMP_COPIED_UMAT) == TEMP_COPIED_UMAT; }
 
+inline void UMatData::markDeviceMemMapped(bool flag)
+{
+  if(flag)
+    flags |= DEVICE_MEM_MAPPED;
+  else
+    flags &= ~DEVICE_MEM_MAPPED;
+}
+
 inline void UMatData::markHostCopyObsolete(bool flag)
 {
     if(flag)

modules/core/perf/opencl/perf_matop.cpp

@@ -139,6 +139,7 @@ OCL_PERF_TEST_P(CopyToFixture, CopyToWithMaskUninit,
         dst.release();
         startTimer();
         src.copyTo(dst, mask);
+        cv::ocl::finish();
         stopTimer();
     }
 

modules/core/src/arithm.cpp

@@ -2980,8 +2980,187 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
 namespace cv
 {
 
-template<typename T> static void
+template <typename T>
-inRange_(const T* src1, size_t step1, const T* src2, size_t step2,
+struct InRange_SSE
+{
+    int operator () (const T *, const T *, const T *, uchar *, int) const
+    {
+        return 0;
+    }
+};
+
+#if CV_SSE2
+
+template <>
+struct InRange_SSE<uchar>
+{
+    int operator () (const uchar * src1, const uchar * src2, const uchar * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        if (USE_SSE2)
+        {
+            __m128i v_full = _mm_set1_epi8(-1), v_128 = _mm_set1_epi8(-128);
+
+            for ( ; x <= len - 16; x += 16 )
+            {
+                __m128i v_src = _mm_add_epi8(_mm_loadu_si128((const __m128i *)(src1 + x)), v_128);
+                __m128i v_mask1 = _mm_cmpgt_epi8(_mm_add_epi8(_mm_loadu_si128((const __m128i *)(src2 + x)), v_128), v_src);
+                __m128i v_mask2 = _mm_cmpgt_epi8(v_src, _mm_add_epi8(_mm_loadu_si128((const __m128i *)(src3 + x)), v_128));
+                _mm_storeu_si128((__m128i *)(dst + x), _mm_andnot_si128(_mm_or_si128(v_mask1, v_mask2), v_full));
+            }
+        }
+
+        return x;
+    }
+};
+
+template <>
+struct InRange_SSE<schar>
+{
+    int operator () (const schar * src1, const schar * src2, const schar * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        if (USE_SSE2)
+        {
+            __m128i v_full = _mm_set1_epi8(-1);
+
+            for ( ; x <= len - 16; x += 16 )
+            {
+                __m128i v_src = _mm_loadu_si128((const __m128i *)(src1 + x));
+                __m128i v_mask1 = _mm_cmpgt_epi8(_mm_loadu_si128((const __m128i *)(src2 + x)), v_src);
+                __m128i v_mask2 = _mm_cmpgt_epi8(v_src, _mm_loadu_si128((const __m128i *)(src3 + x)));
+                _mm_storeu_si128((__m128i *)(dst + x), _mm_andnot_si128(_mm_or_si128(v_mask1, v_mask2), v_full));
+            }
+        }
+
+        return x;
+    }
+};
+
+template <>
+struct InRange_SSE<ushort>
+{
+    int operator () (const ushort * src1, const ushort * src2, const ushort * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        if (USE_SSE2)
+        {
+            __m128i v_zero = _mm_setzero_si128(), v_full = _mm_set1_epi16(-1), v_32768 = _mm_set1_epi16(-32768);
+
+            for ( ; x <= len - 8; x += 8 )
+            {
+                __m128i v_src = _mm_add_epi16(_mm_loadu_si128((const __m128i *)(src1 + x)), v_32768);
+                __m128i v_mask1 = _mm_cmpgt_epi16(_mm_add_epi16(_mm_loadu_si128((const __m128i *)(src2 + x)), v_32768), v_src);
+                __m128i v_mask2 = _mm_cmpgt_epi16(v_src, _mm_add_epi16(_mm_loadu_si128((const __m128i *)(src3 + x)), v_32768));
+                __m128i v_res = _mm_andnot_si128(_mm_or_si128(v_mask1, v_mask2), v_full);
+                _mm_storel_epi64((__m128i *)(dst + x), _mm_packus_epi16(_mm_srli_epi16(v_res, 8), v_zero));
+            }
+        }
+
+        return x;
+    }
+};
+
+template <>
+struct InRange_SSE<short>
+{
+    int operator () (const short * src1, const short * src2, const short * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        if (USE_SSE2)
+        {
+            __m128i v_zero = _mm_setzero_si128(), v_full = _mm_set1_epi16(-1);
+
+            for ( ; x <= len - 8; x += 8 )
+            {
+                __m128i v_src = _mm_loadu_si128((const __m128i *)(src1 + x));
+                __m128i v_mask1 = _mm_cmpgt_epi16(_mm_loadu_si128((const __m128i *)(src2 + x)), v_src);
+                __m128i v_mask2 = _mm_cmpgt_epi16(v_src, _mm_loadu_si128((const __m128i *)(src3 + x)));
+                __m128i v_res = _mm_andnot_si128(_mm_or_si128(v_mask1, v_mask2), v_full);
+                _mm_storel_epi64((__m128i *)(dst + x), _mm_packus_epi16(_mm_srli_epi16(v_res, 8), v_zero));
+            }
+        }
+
+        return x;
+    }
+};
+
+template <>
+struct InRange_SSE<int>
+{
+    int operator () (const int * src1, const int * src2, const int * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        if (USE_SSE2)
+        {
+            __m128i v_zero = _mm_setzero_si128(), v_full = _mm_set1_epi32(-1);
+
+            for ( ; x <= len - 8; x += 8 )
+            {
+                __m128i v_src = _mm_loadu_si128((const __m128i *)(src1 + x));
+                __m128i v_res1 = _mm_or_si128(_mm_cmpgt_epi32(_mm_loadu_si128((const __m128i *)(src2 + x)), v_src),
+                    _mm_cmpgt_epi32(v_src, _mm_loadu_si128((const __m128i *)(src3 + x))));
+
+                v_src = _mm_loadu_si128((const __m128i *)(src1 + x + 4));
+                __m128i v_res2 = _mm_or_si128(_mm_cmpgt_epi32(_mm_loadu_si128((const __m128i *)(src2 + x + 4)), v_src),
+                    _mm_cmpgt_epi32(v_src, _mm_loadu_si128((const __m128i *)(src3 + x + 4))));
+
+                __m128i v_res = _mm_packs_epi32(_mm_srli_epi32(_mm_andnot_si128(v_res1, v_full), 16),
+                                                _mm_srli_epi32(_mm_andnot_si128(v_res2, v_full), 16));
+                _mm_storel_epi64((__m128i *)(dst + x), _mm_packus_epi16(v_res, v_zero));
+            }
+        }
+
+        return x;
+    }
+};
+
+template <>
+struct InRange_SSE<float>
+{
+    int operator () (const float * src1, const float * src2, const float * src3,
+                     uchar * dst, int len) const
+    {
+        int x = 0;
+
+        if (USE_SSE2)
+        {
+            __m128i v_zero = _mm_setzero_si128();
+
+            for ( ; x <= len - 8; x += 8 )
+            {
+                __m128 v_src = _mm_loadu_ps(src1 + x);
+                __m128 v_res1 = _mm_and_ps(_mm_cmple_ps(_mm_loadu_ps(src2 + x), v_src),
+                    _mm_cmple_ps(v_src, _mm_loadu_ps(src3 + x)));
+
+                v_src = _mm_loadu_ps(src1 + x + 4);
+                __m128 v_res2 = _mm_and_ps(_mm_cmple_ps(_mm_loadu_ps(src2 + x + 4), v_src),
+                    _mm_cmple_ps(v_src, _mm_loadu_ps(src3 + x + 4)));
+
+                __m128i v_res1i = _mm_cvtps_epi32(v_res1), v_res2i = _mm_cvtps_epi32(v_res2);
+                __m128i v_res = _mm_packs_epi32(_mm_srli_epi32(v_res1i, 16), _mm_srli_epi32(v_res2i, 16));
+                _mm_storel_epi64((__m128i *)(dst + x), _mm_packus_epi16(v_res, v_zero));
+            }
+        }
+
+        return x;
+    }
+};
+
+#endif
+
+template <typename T>
+static void inRange_(const T* src1, size_t step1, const T* src2, size_t step2,
          const T* src3, size_t step3, uchar* dst, size_t step,
          Size size)
 {
@@ -2989,9 +3168,11 @@ inRange_(const T* src1, size_t step1, const T* src2, size_t step2,
     step2 /= sizeof(src2[0]);
     step3 /= sizeof(src3[0]);
 
+    InRange_SSE<T> vop;
+
     for( ; size.height--; src1 += step1, src2 += step2, src3 += step3, dst += step )
     {
-        int x = 0;
+        int x = vop(src1, src2, src3, dst, size.width);
         #if CV_ENABLE_UNROLLED
         for( ; x <= size.width - 4; x += 4 )
         {

modules/core/src/convert.cpp

@@ -1729,22 +1729,18 @@ static bool ocl_LUT(InputArray _src, InputArray _lut, OutputArray _dst)
     UMat src = _src.getUMat(), lut = _lut.getUMat();
     _dst.create(src.size(), CV_MAKETYPE(ddepth, dcn));
     UMat dst = _dst.getUMat();
-    bool bAligned = (1 == lcn) && (0 == (src.offset % 4)) && (0 == ((dcn * src.cols) % 4));
+    int kercn = lcn == 1 ? std::min(4, ocl::predictOptimalVectorWidth(_dst)) : dcn;
-    // dst.cols == src.cols by params of dst.create
 
     ocl::Kernel k("LUT", ocl::core::lut_oclsrc,
-                  format("-D dcn=%d -D lcn=%d -D srcT=%s -D dstT=%s", bAligned ? 4 : dcn, lcn,
+                  format("-D dcn=%d -D lcn=%d -D srcT=%s -D dstT=%s", kercn, lcn,
-                         ocl::typeToStr(src.depth()), ocl::memopTypeToStr(ddepth)
+                         ocl::typeToStr(src.depth()), ocl::memopTypeToStr(ddepth)));
-                         ));
     if (k.empty())
         return false;
 
-    int cols = bAligned ? dcn * dst.cols / 4 : dst.cols;
-
     k.args(ocl::KernelArg::ReadOnlyNoSize(src), ocl::KernelArg::ReadOnlyNoSize(lut),
-        ocl::KernelArg::WriteOnlyNoSize(dst), dst.rows, cols);
+        ocl::KernelArg::WriteOnly(dst, dcn, kercn));
 
-    size_t globalSize[2] = { cols, (dst.rows + 3) / 4 };
+    size_t globalSize[2] = { dst.cols * dcn / kercn, (dst.rows + 3) / 4 };
     return k.run(2, globalSize, NULL, false);
 }
 

modules/core/src/drawing.cpp

@@ -1584,6 +1584,24 @@ void line( InputOutputArray _img, Point pt1, Point pt2, const Scalar& color,
     ThickLine( img, pt1, pt2, buf, thickness, line_type, 3, shift );
 }
 
+void arrowedLine(InputOutputArray img, Point pt1, Point pt2, const Scalar& color,
+           int thickness, int line_type, int shift, double tipLength)
+{
+    const double tipSize = norm(pt1-pt2)*tipLength; // Factor to normalize the size of the tip depending on the length of the arrow
+
+    line(img, pt1, pt2, color, thickness, line_type, shift);
+
+    const double angle = atan2( (double) pt1.y - pt2.y, (double) pt1.x - pt2.x );
+
+    Point p(cvRound(pt2.x + tipSize * cos(angle + CV_PI / 4)),
+        cvRound(pt2.y + tipSize * sin(angle + CV_PI / 4)));
+    line(img, p, pt2, color, thickness, line_type, shift);
+
+    p.x = cvRound(pt2.x + tipSize * cos(angle - CV_PI / 4));
+    p.y = cvRound(pt2.y + tipSize * sin(angle - CV_PI / 4));
+    line(img, p, pt2, color, thickness, line_type, shift);
+}
+
 void rectangle( InputOutputArray _img, Point pt1, Point pt2,
                 const Scalar& color, int thickness,
                 int lineType, int shift )

modules/core/src/dxt.cpp

@@ -2080,32 +2080,32 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
     {
         if ((flags & DFT_ROWS) == 0)
         {
-            if (!real_transform)
+            if (src.channels() == 2 && !(inv && (flags & DFT_REAL_OUTPUT)))
             {
-                if (ippi_DFT_C_32F(src,dst, inv, ipp_norm_flag))
+                if (ippi_DFT_C_32F(src, dst, inv, ipp_norm_flag))
                     return;
                 setIppErrorStatus();
             }
-            else if (inv || !(flags & DFT_COMPLEX_OUTPUT))
+            if (src.channels() == 1 && (inv || !(flags & DFT_COMPLEX_OUTPUT)))
             {
-                if (ippi_DFT_R_32F(src,dst, inv, ipp_norm_flag))
+                if (ippi_DFT_R_32F(src, dst, inv, ipp_norm_flag))
                     return;
                 setIppErrorStatus();
             }
         }
         else
         {
-            if (!real_transform)
+            if (src.channels() == 2 && !(inv && (flags & DFT_REAL_OUTPUT)))
             {
                 ippiDFT_C_Func ippiFunc = inv ? (ippiDFT_C_Func)ippiDFTInv_CToC_32fc_C1R : (ippiDFT_C_Func)ippiDFTFwd_CToC_32fc_C1R;
-                if (Dft_C_IPPLoop(src,dst, IPPDFT_C_Functor(ippiFunc),ipp_norm_flag))
+                if (Dft_C_IPPLoop(src, dst, IPPDFT_C_Functor(ippiFunc),ipp_norm_flag))
                     return;
                 setIppErrorStatus();
             }
-            else if (inv || !(flags & DFT_COMPLEX_OUTPUT))
+            if (src.channels() == 1 && (inv || !(flags & DFT_COMPLEX_OUTPUT)))
             {
                 ippiDFT_R_Func ippiFunc = inv ? (ippiDFT_R_Func)ippiDFTInv_PackToR_32f_C1R : (ippiDFT_R_Func)ippiDFTFwd_RToPack_32f_C1R;
-                if (Dft_R_IPPLoop(src,dst, IPPDFT_R_Functor(ippiFunc),ipp_norm_flag))
+                if (Dft_R_IPPLoop(src, dst, IPPDFT_R_Functor(ippiFunc),ipp_norm_flag))
                     return;
                 setIppErrorStatus();
             }

modules/core/src/mathfuncs.cpp

@@ -348,7 +348,18 @@ static void InvSqrt_32f(const float* src, float* dst, int len)
 
 static void InvSqrt_64f(const double* src, double* dst, int len)
 {
-    for( int i = 0; i < len; i++ )
+    int i = 0;
+
+#if CV_SSE2
+    if (USE_SSE2)
+    {
+        __m128d v_1 = _mm_set1_pd(1.0);
+        for ( ; i <= len - 2; i += 2)
+            _mm_storeu_pd(dst + i, _mm_div_pd(v_1, _mm_sqrt_pd(_mm_loadu_pd(src + i))));
+    }
+#endif
+
+    for( ; i < len; i++ )
         dst[i] = 1/std::sqrt(src[i]);
 }
 
@@ -2543,12 +2554,33 @@ void patchNaNs( InputOutputArray _a, double _val )
     NAryMatIterator it(arrays, (uchar**)ptrs);
     size_t len = it.size*a.channels();
     Cv32suf val;
-    val.f = (float)_val;
+    float fval = (float)_val;
+    val.f = fval;
+
+#if CV_SSE2
+    __m128i v_mask1 = _mm_set1_epi32(0x7fffffff), v_mask2 = _mm_set1_epi32(0x7f800000);
+    __m128i v_val = _mm_set1_epi32(val.i);
+#endif
 
     for( size_t i = 0; i < it.nplanes; i++, ++it )
     {
         int* tptr = ptrs[0];
-        for( size_t j = 0; j < len; j++ )
+        size_t j = 0;
+
+#if CV_SSE2
+        if (USE_SSE2)
+        {
+            for ( ; j < len; j += 4)
+            {
+                __m128i v_src = _mm_loadu_si128((__m128i const *)(tptr + j));
+                __m128i v_cmp_mask = _mm_cmplt_epi32(v_mask2, _mm_and_si128(v_src, v_mask1));
+                __m128i v_res = _mm_or_si128(_mm_andnot_si128(v_cmp_mask, v_src), _mm_and_si128(v_cmp_mask, v_val));
+                _mm_storeu_si128((__m128i *)(tptr + j), v_res);
+            }
+        }
+#endif
+
+        for( ; j < len; j++ )
             if( (tptr[j] & 0x7fffffff) > 0x7f800000 )
                 tptr[j] = val.i;
     }

modules/core/src/matrix.cpp

@@ -2758,21 +2758,30 @@ namespace cv {
 
 static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s )
 {
-    int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type),
+    int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), kercn = cn;
-            sctype = CV_MAKE_TYPE(depth, cn == 3 ? 4 : cn),
+    if (cn == 1)
+    {
+        kercn = std::min(ocl::predictOptimalVectorWidth(_m), 4);
+        if (kercn != 4)
+            kercn = 1;
+    }
+    int sctype = CV_MAKE_TYPE(depth, cn == 3 ? 4 : cn),
             rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
 
     ocl::Kernel k("setIdentity", ocl::core::set_identity_oclsrc,
-                  format("-D T=%s -D T1=%s -D cn=%d -D ST=%s", ocl::memopTypeToStr(type),
+                  format("-D T=%s -D T1=%s -D cn=%d -D ST=%s -D kercn=%d -D rowsPerWI=%d",
-                         ocl::memopTypeToStr(depth), cn, ocl::memopTypeToStr(sctype)));
+                         ocl::memopTypeToStr(CV_MAKE_TYPE(depth, kercn)),
+                         ocl::memopTypeToStr(depth), cn,
+                         ocl::memopTypeToStr(sctype),
+                         kercn, rowsPerWI));
     if (k.empty())
         return false;
 
     UMat m = _m.getUMat();
-    k.args(ocl::KernelArg::WriteOnly(m), ocl::KernelArg::Constant(Mat(1, 1, sctype, s)),
+    k.args(ocl::KernelArg::WriteOnly(m, cn, kercn),
-           rowsPerWI);
+           ocl::KernelArg::Constant(Mat(1, 1, sctype, s)));
 
-    size_t globalsize[2] = { m.cols, (m.rows + rowsPerWI - 1) / rowsPerWI };
+    size_t globalsize[2] = { m.cols * cn / kercn, (m.rows + rowsPerWI - 1) / rowsPerWI };
     return k.run(2, globalsize, NULL, false);
 }
 
@@ -3441,8 +3450,11 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
     const int min_opt_cols = 128, buf_cols = 32;
     int sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype),
             ddepth = CV_MAT_DEPTH(dtype), ddepth0 = ddepth;
-    bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0,
+    const ocl::Device &defDev = ocl::Device::getDefault();
-            useOptimized = 1 == dim && _src.cols() > min_opt_cols;
+    bool doubleSupport = defDev.doubleFPConfig() > 0;
+
+    size_t wgs = defDev.maxWorkGroupSize();
+    bool useOptimized = 1 == dim && _src.cols() > min_opt_cols && (wgs >= buf_cols);
 
     if (!doubleSupport && (sdepth == CV_64F || ddepth == CV_64F))
         return false;
@@ -3455,78 +3467,80 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
 
     const char * const ops[4] = { "OCL_CV_REDUCE_SUM", "OCL_CV_REDUCE_AVG",
                                   "OCL_CV_REDUCE_MAX", "OCL_CV_REDUCE_MIN" };
-    char cvt[2][40];
-
     int wdepth = std::max(ddepth, CV_32F);
-    cv::String build_opt = format("-D %s -D dim=%d -D cn=%d -D ddepth=%d"
-                                  " -D srcT=%s -D dstT=%s -D dstT0=%s -D convertToWT=%s"
-                                  " -D convertToDT=%s -D convertToDT0=%s%s",
-                                  ops[op], dim, cn, ddepth, ocl::typeToStr(useOptimized ? ddepth : sdepth),
-                                  ocl::typeToStr(ddepth), ocl::typeToStr(ddepth0),
-                                  ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0]),
-                                  ocl::convertTypeStr(sdepth, ddepth, 1, cvt[0]),
-                                  ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[1]),
-                                  doubleSupport ? " -D DOUBLE_SUPPORT" : "");
-
     if (useOptimized)
     {
-        cv::String build_opt_pre = format("-D OP_REDUCE_PRE -D BUF_COLS=%d -D %s -D dim=1"
+        size_t tileHeight = (size_t)(wgs / buf_cols);
-                                          "  -D cn=%d -D ddepth=%d -D srcT=%s -D dstT=%s -D convertToDT=%s%s",
+        if (defDev.isIntel())
-                                          buf_cols, ops[op], cn, ddepth, ocl::typeToStr(sdepth), ocl::typeToStr(ddepth),
+        {
-                                          ocl::convertTypeStr(sdepth, ddepth, 1, cvt[0]),
+            static const size_t maxItemInGroupCount = 16;
-                                          doubleSupport ? " -D DOUBLE_SUPPORT" : "");
+            tileHeight = min(tileHeight, defDev.localMemSize() / buf_cols / CV_ELEM_SIZE(CV_MAKETYPE(wdepth, cn)) / maxItemInGroupCount);
-        ocl::Kernel kpre("reduce_horz_pre", ocl::core::reduce2_oclsrc, build_opt_pre);
+        }
-        if (kpre.empty())
+        char cvt[3][40];
+        cv::String build_opt = format("-D OP_REDUCE_PRE -D BUF_COLS=%d -D TILE_HEIGHT=%d -D %s -D dim=1"
+                                            " -D cn=%d -D ddepth=%d"
+                                            " -D srcT=%s -D bufT=%s -D dstT=%s"
+                                            " -D convertToWT=%s -D convertToBufT=%s -D convertToDT=%s%s",
+                                            buf_cols, tileHeight, ops[op], cn, ddepth,
+                                            ocl::typeToStr(sdepth),
+                                            ocl::typeToStr(ddepth),
+                                            ocl::typeToStr(ddepth0),
+                                            ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0]),
+                                            ocl::convertTypeStr(sdepth, ddepth, 1, cvt[1]),
+                                            ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[2]),
+                                            doubleSupport ? " -D DOUBLE_SUPPORT" : "");
+        ocl::Kernel k("reduce_horz_opt", ocl::core::reduce2_oclsrc, build_opt);
+        if (k.empty())
             return false;
-
-        ocl::Kernel kmain("reduce", ocl::core::reduce2_oclsrc, build_opt);
-        if (kmain.empty())
-            return false;
-
         UMat src = _src.getUMat();
         Size dsize(1, src.rows);
         _dst.create(dsize, dtype);
         UMat dst = _dst.getUMat();
 
-        UMat buf(src.rows, buf_cols, dst.type());
+        if (op0 == CV_REDUCE_AVG)
-
+            k.args(ocl::KernelArg::ReadOnly(src),
-        kpre.args(ocl::KernelArg::ReadOnly(src),
+                      ocl::KernelArg::WriteOnlyNoSize(dst), 1.0f / src.cols);
-                  ocl::KernelArg::WriteOnlyNoSize(buf));
+        else
+            k.args(ocl::KernelArg::ReadOnly(src),
+                      ocl::KernelArg::WriteOnlyNoSize(dst));
 
+        size_t localSize[2] = { buf_cols, tileHeight};
         size_t globalSize[2] = { buf_cols, src.rows };
-        if (!kpre.run(2, globalSize, NULL, false))
+        return k.run(2, globalSize, localSize, false);
+    }
+    else
+    {
+        char cvt[2][40];
+        cv::String build_opt = format("-D %s -D dim=%d -D cn=%d -D ddepth=%d"
+                                      " -D srcT=%s -D dstT=%s -D dstT0=%s -D convertToWT=%s"
+                                      " -D convertToDT=%s -D convertToDT0=%s%s",
+                                      ops[op], dim, cn, ddepth, ocl::typeToStr(useOptimized ? ddepth : sdepth),
+                                      ocl::typeToStr(ddepth), ocl::typeToStr(ddepth0),
+                                      ocl::convertTypeStr(ddepth, wdepth, 1, cvt[0]),
+                                      ocl::convertTypeStr(sdepth, ddepth, 1, cvt[0]),
+                                      ocl::convertTypeStr(wdepth, ddepth0, 1, cvt[1]),
+                                      doubleSupport ? " -D DOUBLE_SUPPORT" : "");
+
+        ocl::Kernel k("reduce", ocl::core::reduce2_oclsrc, build_opt);
+        if (k.empty())
             return false;
 
+        UMat src = _src.getUMat();
+        Size dsize(dim == 0 ? src.cols : 1, dim == 0 ? 1 : src.rows);
+        _dst.create(dsize, dtype);
+        UMat dst = _dst.getUMat();
+
+        ocl::KernelArg srcarg = ocl::KernelArg::ReadOnly(src),
+                temparg = ocl::KernelArg::WriteOnlyNoSize(dst);
+
         if (op0 == CV_REDUCE_AVG)
-            kmain.args(ocl::KernelArg::ReadOnly(buf),
+            k.args(srcarg, temparg, 1.0f / (dim == 0 ? src.rows : src.cols));
-                       ocl::KernelArg::WriteOnlyNoSize(dst), 1.0f / src.cols);
         else
-            kmain.args(ocl::KernelArg::ReadOnly(buf),
+            k.args(srcarg, temparg);
-                       ocl::KernelArg::WriteOnlyNoSize(dst));
 
-        globalSize[0] = src.rows;
+        size_t globalsize = std::max(dsize.width, dsize.height);
-        return kmain.run(1, globalSize, NULL, false);
+        return k.run(1, &globalsize, NULL, false);
     }
-
-    ocl::Kernel k("reduce", ocl::core::reduce2_oclsrc, build_opt);
-    if (k.empty())
-        return false;
-
-    UMat src = _src.getUMat();
-    Size dsize(dim == 0 ? src.cols : 1, dim == 0 ? 1 : src.rows);
-    _dst.create(dsize, dtype);
-    UMat dst = _dst.getUMat();
-
-    ocl::KernelArg srcarg = ocl::KernelArg::ReadOnly(src),
-            temparg = ocl::KernelArg::WriteOnlyNoSize(dst);
-
-    if (op0 == CV_REDUCE_AVG)
-        k.args(srcarg, temparg, 1.0f / (dim == 0 ? src.rows : src.cols));
-    else
-        k.args(srcarg, temparg);
-
-    size_t globalsize = std::max(dsize.width, dsize.height);
-    return k.run(1, &globalsize, NULL, false);
 }
 
 }

modules/core/src/ocl.cpp

@@ -3494,9 +3494,8 @@ public:
     OpenCLBufferPoolImpl()
         : currentReservedSize(0), maxReservedSize(0)
     {
-        // Note: Buffer pool is disabled by default,
+        int poolSize = ocl::Device::getDefault().isIntel() ? 1 << 27 : 0;
-        //       because we didn't receive significant performance improvement
+        maxReservedSize = getConfigurationParameterForSize("OPENCV_OPENCL_BUFFERPOOL_LIMIT", poolSize);
-        maxReservedSize = getConfigurationParameterForSize("OPENCV_OPENCL_BUFFERPOOL_LIMIT", 0);
     }
     virtual ~OpenCLBufferPoolImpl()
     {
@@ -3739,6 +3738,7 @@ public:
                 u->handle = clCreateBuffer(ctx_handle, CL_MEM_COPY_HOST_PTR|CL_MEM_READ_WRITE|createFlags,
                                            u->size, u->origdata, &retval);
                 tempUMatFlags = UMatData::TEMP_COPIED_UMAT;
+
             }
             if(!u->handle || retval != CL_SUCCESS)
                 return false;
@@ -3880,6 +3880,7 @@ public:
                 if(u->data && retval == CL_SUCCESS)
                 {
                     u->markHostCopyObsolete(false);
+                    u->markDeviceMemMapped(true);
                     return;
                 }
 
@@ -3908,6 +3909,7 @@ public:
         if(!u)
             return;
 
+
         CV_Assert(u->handle != 0);
 
         UMatDataAutoLock autolock(u);
@@ -3918,8 +3920,10 @@ public:
 
         cl_command_queue q = (cl_command_queue)Queue::getDefault().ptr();
         cl_int retval = 0;
-        if( !u->copyOnMap() && u->data )
+        if( !u->copyOnMap() && u->deviceMemMapped() )
         {
+            CV_Assert(u->data != NULL);
+            u->markDeviceMemMapped(false);
             CV_Assert( (retval = clEnqueueUnmapMemObject(q,
                                 (cl_mem)u->handle, u->data, 0, 0, 0)) == CL_SUCCESS );
             CV_OclDbgAssert(clFinish(q) == CL_SUCCESS);

modules/core/src/opencl/lut.cl

@@ -36,114 +36,118 @@
 
 #if lcn == 1
     #if dcn == 4
-        #define LUT_OP(num)\
+        #define LUT_OP  \
-            int idx = *(__global const int *)(srcptr + mad24(num, src_step, src_index));\
+            int idx = *(__global const int *)(srcptr + src_index); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            dst[0] = lut_l[idx & 0xff];\
+            dst[0] = lut_l[idx & 0xff]; \
-            dst[1] = lut_l[(idx >> 8) & 0xff];\
+            dst[1] = lut_l[(idx >> 8) & 0xff]; \
-            dst[2] = lut_l[(idx >> 16) & 0xff];\
+            dst[2] = lut_l[(idx >> 16) & 0xff]; \
             dst[3] = lut_l[(idx >> 24) & 0xff];
     #elif dcn == 3
-        #define LUT_OP(num)\
+        #define LUT_OP  \
-            uchar3 idx = vload3(0, srcptr + mad24(num, src_step, src_index));\
+            uchar3 idx = vload3(0, srcptr + src_index); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            dst[0] = lut_l[idx.x];\
+            dst[0] = lut_l[idx.x]; \
-            dst[1] = lut_l[idx.y];\
+            dst[1] = lut_l[idx.y]; \
             dst[2] = lut_l[idx.z];
     #elif dcn == 2
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            short idx = *(__global const short *)(srcptr + mad24(num, src_step, src_index));\
+            short idx = *(__global const short *)(srcptr + src_index); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            dst[0] = lut_l[idx & 0xff];\
+            dst[0] = lut_l[idx & 0xff]; \
             dst[1] = lut_l[(idx >> 8) & 0xff];
     #elif dcn == 1
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            uchar idx = (srcptr + mad24(num, src_step, src_index))[0];\
+            uchar idx = (srcptr + src_index)[0]; \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
             dst[0] = lut_l[idx];
     #else
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            __global const srcT * src = (__global const srcT *)(srcptr + mad24(num, src_step, src_index));\
+            __global const srcT * src = (__global const srcT *)(srcptr + src_index); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            for (int cn = 0; cn < dcn; ++cn)\
+            for (int cn = 0; cn < dcn; ++cn) \
                 dst[cn] = lut_l[src[cn]];
     #endif
 #else
     #if dcn == 4
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            __global const uchar4 *src_pixel = (__global const uchar4 *)(srcptr + mad24(num, src_step, src_index));\
+            __global const uchar4 * src_pixel = (__global const uchar4 *)(srcptr + src_index); \
-            int4 idx = convert_int4(src_pixel[0]) * lcn + (int4)(0, 1, 2, 3);\
+            int4 idx = mad24(convert_int4(src_pixel[0]), (int4)(lcn), (int4)(0, 1, 2, 3)); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            dst[0] = lut_l[idx.x];\
+            dst[0] = lut_l[idx.x]; \
-            dst[1] = lut_l[idx.y];\
+            dst[1] = lut_l[idx.y]; \
-            dst[2] = lut_l[idx.z];\
+            dst[2] = lut_l[idx.z]; \
             dst[3] = lut_l[idx.w];
     #elif dcn == 3
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            uchar3 src_pixel = vload3(0, srcptr + mad24(num, src_step, src_index));\
+            uchar3 src_pixel = vload3(0, srcptr + src_index); \
-            int3 idx = convert_int3(src_pixel) * lcn + (int3)(0, 1, 2);\
+            int3 idx = mad24(convert_int3(src_pixel), (int3)(lcn), (int3)(0, 1, 2)); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            dst[0] = lut_l[idx.x];\
+            dst[0] = lut_l[idx.x]; \
-            dst[1] = lut_l[idx.y];\
+            dst[1] = lut_l[idx.y]; \
             dst[2] = lut_l[idx.z];
     #elif dcn == 2
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            __global const uchar2 *src_pixel = (__global const uchar2 *)(srcptr + mad24(num, src_step, src_index));\
+            __global const uchar2 * src_pixel = (__global const uchar2 *)(srcptr + src_index); \
-            int2 idx = convert_int2(src_pixel[0]) * lcn + (int2)(0, 1);\
+            int2 idx = mad24(convert_int2(src_pixel[0]), lcn, (int2)(0, 1)); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            dst[0] = lut_l[idx.x];\
+            dst[0] = lut_l[idx.x]; \
             dst[1] = lut_l[idx.y];
     #elif dcn == 1 //error case (1 < lcn) ==> lcn == scn == dcn
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            uchar idx = (srcptr + mad24(num, src_step, src_index))[0];\
+            uchar idx = (srcptr + src_index)[0]; \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
             dst[0] = lut_l[idx];
     #else
-        #define LUT_OP(num)\
+        #define LUT_OP \
-            __global const srcT *src = (__global const srcT *)(srcptr + mad24(num, src_step, src_index));\
+            __global const srcT * src = (__global const srcT *)(srcptr + src_index); \
-            dst = (__global dstT *)(dstptr + mad24(num, dst_step, dst_index));\
+            dst = (__global dstT *)(dstptr + dst_index); \
-            for (int cn = 0; cn < dcn; ++cn)\
+            for (int cn = 0; cn < dcn; ++cn) \
                 dst[cn] = lut_l[mad24(src[cn], lcn, cn)];
     #endif
 #endif
 
-#define LOCAL_LUT_INIT\
-    {\
-        __global const dstT * lut = (__global const dstT *)(lutptr + lut_offset);\
-        int init = mad24((int)get_local_id(1), (int)get_local_size(0), (int)get_local_id(0));\
-        int step = get_local_size(0) * get_local_size(1);\
-        for (int i = init; i < 256 * lcn; i += step)\
-        {\
-            lut_l[i] = lut[i];\
-        }\
-        barrier(CLK_LOCAL_MEM_FENCE);\
-    }
-
 __kernel void LUT(__global const uchar * srcptr, int src_step, int src_offset,
                   __global const uchar * lutptr, int lut_step, int lut_offset,
                   __global uchar * dstptr, int dst_step, int dst_offset, int rows, int cols)
 {
-    __local dstT lut_l[256 * lcn];
-    LOCAL_LUT_INIT;
-
     int x = get_global_id(0);
-    int y = 4 * get_global_id(1);
+    int y = get_global_id(1) << 2;
+
+    __local dstT lut_l[256 * lcn];
+    __global const dstT * lut = (__global const dstT *)(lutptr + lut_offset);
+
+    for (int i = mad24((int)get_local_id(1), (int)get_local_size(0), (int)get_local_id(0)),
+             step = get_local_size(0) * get_local_size(1); i < 256 * lcn; i += step)
+        lut_l[i] = lut[i];
+    barrier(CLK_LOCAL_MEM_FENCE);
 
     if (x < cols && y < rows)
     {
         int src_index = mad24(y, src_step, mad24(x, (int)sizeof(srcT) * dcn, src_offset));
         int dst_index = mad24(y, dst_step, mad24(x, (int)sizeof(dstT) * dcn, dst_offset));
+
         __global dstT * dst;
-        LUT_OP(0);
+
+        LUT_OP;
+
         if (y < rows - 1)
         {
-            LUT_OP(1);
+            src_index += src_step;
+            dst_index += dst_step;
+            LUT_OP;
+
             if (y < rows - 2)
             {
-                LUT_OP(2);
+                src_index += src_step;
+                dst_index += dst_step;
+                LUT_OP;
+
                 if (y < rows - 3)
                 {
-                    LUT_OP(3);
+                    src_index += src_step;
+                    dst_index += dst_step;
+                    LUT_OP;
                 }
             }
         }

modules/core/src/opencl/minmaxloc.cl

@@ -42,9 +42,13 @@
 #if wdepth <= 4
 #define MIN_ABS(a) convertFromU(abs(a))
 #define MIN_ABS2(a, b) convertFromU(abs_diff(a, b))
+#define MIN(a, b) min(a, b)
+#define MAX(a, b) max(a, b)
 #else
 #define MIN_ABS(a) fabs(a)
 #define MIN_ABS2(a, b) fabs(a - b)
+#define MIN(a, b) fmin(a, b)
+#define MAX(a, b) fmax(a, b)
 #endif
 
 #if kercn != 3
@@ -60,44 +64,41 @@
 #define srcTSIZE (int)sizeof(srcT1)
 #endif
 
-#ifdef NEED_MINLOC
-#define CALC_MINLOC(inc) minloc = id + inc
-#else
-#define CALC_MINLOC(inc)
-#endif
-
-#ifdef NEED_MAXLOC
-#define CALC_MAXLOC(inc) maxloc = id + inc
-#else
-#define CALC_MAXLOC(inc)
-#endif
-
 #ifdef NEED_MINVAL
+#ifdef NEED_MINLOC
 #define CALC_MIN(p, inc) \
     if (minval > temp.p) \
     { \
         minval = temp.p; \
-        CALC_MINLOC(inc); \
+        minloc = id + inc; \
     }
 #else
+#define CALC_MIN(p, inc) \
+    minval = MIN(minval, temp.p);
+#endif
+#else
 #define CALC_MIN(p, inc)
 #endif
 
 #ifdef NEED_MAXVAL
+#ifdef NEED_MAXLOC
 #define CALC_MAX(p, inc) \
     if (maxval < temp.p) \
     { \
         maxval = temp.p; \
-        CALC_MAXLOC(inc); \
+        maxloc = id + inc; \
     }
 #else
+#define CALC_MAX(p, inc) \
+    maxval = MAX(maxval, temp.p);
+#endif
+#else
 #define CALC_MAX(p, inc)
 #endif
 
 #ifdef OP_CALC2
 #define CALC_MAX2(p) \
-    if (maxval2 < temp.p) \
+    maxval2 = MAX(maxval2, temp.p);
-        maxval2 = temp.p;
 #else
 #define CALC_MAX2(p)
 #endif
@@ -208,25 +209,28 @@ __kernel void minmaxloc(__global const uchar * srcptr, int src_step, int src_off
 
 #if kercn == 1
 #ifdef NEED_MINVAL
+#if NEED_MINLOC
             if (minval > temp)
             {
                 minval = temp;
-#ifdef NEED_MINLOC
                 minloc = id;
-#endif
             }
+#else
+            minval = MIN(minval, temp);
+#endif
 #endif
 #ifdef NEED_MAXVAL
+#ifdef NEED_MAXLOC
             if (maxval < temp)
             {
                 maxval = temp;
-#ifdef NEED_MAXLOC
                 maxloc = id;
-#endif
             }
+#else
+            maxval = MAX(maxval, temp);
+#endif
 #ifdef OP_CALC2
-            if (maxval2 < temp2)
+            maxval2 = MAX(maxval2, temp2);
-                maxval2 = temp2;
 #endif
 #endif
 #elif kercn >= 2
@@ -282,32 +286,35 @@ __kernel void minmaxloc(__global const uchar * srcptr, int src_step, int src_off
     {
         int lid3 = lid - WGS2_ALIGNED;
 #ifdef NEED_MINVAL
+#ifdef NEED_MINLOC
         if (localmem_min[lid3] >= minval)
         {
-#ifdef NEED_MINLOC
             if (localmem_min[lid3] == minval)
                 localmem_minloc[lid3] = min(localmem_minloc[lid3], minloc);
             else
                 localmem_minloc[lid3] = minloc,
-#endif
+            localmem_min[lid3] = minval;
-                localmem_min[lid3] = minval;
         }
+#else
+        localmem_min[lid3] = MIN(localmem_min[lid3], minval);
+#endif
 #endif
 #ifdef NEED_MAXVAL
+#ifdef NEED_MAXLOC
         if (localmem_max[lid3] <= maxval)
         {
-#ifdef NEED_MAXLOC
             if (localmem_max[lid3] == maxval)
                 localmem_maxloc[lid3] = min(localmem_maxloc[lid3], maxloc);
             else
                 localmem_maxloc[lid3] = maxloc,
-#endif
+            localmem_max[lid3] = maxval;
-                localmem_max[lid3] = maxval;
         }
+#else
+        localmem_max[lid3] = MAX(localmem_max[lid3], maxval);
+#endif
 #endif
 #ifdef OP_CALC2
-        if (localmem_max2[lid3] < maxval2)
+        localmem_max2[lid3] = MAX(localmem_max2[lid3], maxval2);
-            localmem_max2[lid3] = maxval2;
 #endif
     }
     barrier(CLK_LOCAL_MEM_FENCE);
@@ -319,32 +326,35 @@ __kernel void minmaxloc(__global const uchar * srcptr, int src_step, int src_off
             int lid2 = lsize + lid;
 
 #ifdef NEED_MINVAL
+#ifdef NEED_MAXLOC
             if (localmem_min[lid] >= localmem_min[lid2])
             {
-#ifdef NEED_MINLOC
                 if (localmem_min[lid] == localmem_min[lid2])
                     localmem_minloc[lid] = min(localmem_minloc[lid2], localmem_minloc[lid]);
                 else
                     localmem_minloc[lid] = localmem_minloc[lid2],
-#endif
+                localmem_min[lid] = localmem_min[lid2];
-                    localmem_min[lid] = localmem_min[lid2];
             }
+#else
+            localmem_min[lid] = MIN(localmem_min[lid], localmem_min[lid2]);
+#endif
 #endif
 #ifdef NEED_MAXVAL
+#ifdef NEED_MAXLOC
             if (localmem_max[lid] <= localmem_max[lid2])
             {
-#ifdef NEED_MAXLOC
                 if (localmem_max[lid] == localmem_max[lid2])
                     localmem_maxloc[lid] = min(localmem_maxloc[lid2], localmem_maxloc[lid]);
                 else
                     localmem_maxloc[lid] = localmem_maxloc[lid2],
-#endif
+                localmem_max[lid] = localmem_max[lid2];
-                    localmem_max[lid] = localmem_max[lid2];
             }
+#else
+            localmem_max[lid] = MAX(localmem_max[lid], localmem_max[lid2]);
+#endif
 #endif
 #ifdef OP_CALC2
-            if (localmem_max2[lid] < localmem_max2[lid2])
+            localmem_max2[lid] = MAX(localmem_max2[lid], localmem_max2[lid2]);
-                localmem_max2[lid] = localmem_max2[lid2];
 #endif
         }
         barrier(CLK_LOCAL_MEM_FENCE);

modules/core/src/opencl/reduce2.cl

@@ -81,29 +81,34 @@
 #define PROCESS_ELEM(acc, value) acc += value
 #elif defined OCL_CV_REDUCE_MAX
 #define INIT_VALUE MIN_VAL
-#define PROCESS_ELEM(acc, value) acc = value > acc ? value : acc
+#define PROCESS_ELEM(acc, value) acc = max(value, acc)
 #elif defined OCL_CV_REDUCE_MIN
 #define INIT_VALUE MAX_VAL
-#define PROCESS_ELEM(acc, value) acc = value < acc ? value : acc
+#define PROCESS_ELEM(acc, value) acc = min(value, acc)
 #else
 #error "No operation is specified"
 #endif
 
 #ifdef OP_REDUCE_PRE
 
-__kernel void reduce_horz_pre(__global const uchar * srcptr, int src_step, int src_offset, int rows, int cols,
+__kernel void reduce_horz_opt(__global const uchar * srcptr, int src_step, int src_offset, int rows, int cols,
-                     __global uchar * bufptr, int buf_step, int buf_offset)
+                     __global uchar * dstptr, int dst_step, int dst_offset
+#ifdef OCL_CV_REDUCE_AVG
+                     , float fscale
+#endif
+                     )
 {
+    __local bufT lsmem[TILE_HEIGHT][BUF_COLS][cn];
+
     int x = get_global_id(0);
     int y = get_global_id(1);
-    if (x < BUF_COLS)
+    int liy = get_local_id(1);
+    if ((x < BUF_COLS) && (y < rows))
     {
         int src_index = mad24(y, src_step, mad24(x, (int)sizeof(srcT) * cn, src_offset));
-        int buf_index = mad24(y, buf_step, mad24(x, (int)sizeof(dstT) * cn, buf_offset));
 
         __global const srcT * src = (__global const srcT *)(srcptr + src_index);
-        __global dstT * buf = (__global dstT *)(bufptr + buf_index);
+        bufT tmp[cn] = { INIT_VALUE };
-        dstT tmp[cn] = { INIT_VALUE };
 
         int src_step_mul = BUF_COLS * cn;
         for (int idx = x; idx < cols; idx += BUF_COLS, src += src_step_mul)
@@ -111,14 +116,49 @@ __kernel void reduce_horz_pre(__global const uchar * srcptr, int src_step, int s
             #pragma unroll
             for (int c = 0; c < cn; ++c)
             {
-                dstT value = convertToDT(src[c]);
+                bufT value = convertToBufT(src[c]);
                 PROCESS_ELEM(tmp[c], value);
             }
         }
 
         #pragma unroll
         for (int c = 0; c < cn; ++c)
-            buf[c] = tmp[c];
+            lsmem[liy][x][c] = tmp[c];
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if ((x < BUF_COLS / 2) && (y < rows))
+    {
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+        {
+            PROCESS_ELEM(lsmem[liy][x][c], lsmem[liy][x +  BUF_COLS / 2][c]);
+        }
+    }
+    barrier(CLK_LOCAL_MEM_FENCE);
+    if ((x == 0) && (y < rows))
+    {
+        int dst_index = mad24(y, dst_step, dst_offset);
+
+        __global dstT * dst = (__global dstT *)(dstptr + dst_index);
+        bufT tmp[cn] = { INIT_VALUE };
+
+        #pragma unroll
+        for (int xin = 0; xin < BUF_COLS / 2; xin ++)
+        {
+            #pragma unroll
+            for (int c = 0; c < cn; ++c)
+            {
+                PROCESS_ELEM(tmp[c], lsmem[liy][xin][c]);
+            }
+        }
+
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+#ifdef OCL_CV_REDUCE_AVG
+            dst[c] = convertToDT(convertToWT(tmp[c]) * fscale);
+#else
+            dst[c] = convertToDT(tmp[c]);
+#endif
     }
 }
 

modules/core/src/opencl/set_identity.cl

@@ -43,20 +43,18 @@
 //
 //M*/
 
-#if cn != 3
+#if kercn != 3
-#define loadpix(addr) *(__global const T *)(addr)
 #define storepix(val, addr)  *(__global T *)(addr) = val
 #define TSIZE (int)sizeof(T)
 #define scalar scalar_
 #else
-#define loadpix(addr) vload3(0, (__global const T1 *)(addr))
 #define storepix(val, addr) vstore3(val, 0, (__global T1 *)(addr))
 #define TSIZE ((int)sizeof(T1)*3)
 #define scalar (T)(scalar_.x, scalar_.y, scalar_.z)
 #endif
 
 __kernel void setIdentity(__global uchar * srcptr, int src_step, int src_offset, int rows, int cols,
-                          ST scalar_, int rowsPerWI)
+                          ST scalar_)
 {
     int x = get_global_id(0);
     int y0 = get_global_id(1) * rowsPerWI;
@@ -65,7 +63,35 @@ __kernel void setIdentity(__global uchar * srcptr, int src_step, int src_offset,
     {
         int src_index = mad24(y0, src_step, mad24(x, TSIZE, src_offset));
 
-        for (int y = y0, y1 = min(rows, y0 + rowsPerWI); y < y1; ++y, src_index += src_step)
+#if kercn == cn
-            storepix(x == y ? scalar : (T)(0), srcptr + src_index);
+        #pragma unroll
+        for (int y = y0, i = 0, y1 = min(rows, y0 + rowsPerWI); i < rowsPerWI; ++y, ++i, src_index += src_step)
+            if (y < y1)
+                storepix(x == y ? scalar : (T)(0), srcptr + src_index);
+#elif kercn == 4 && cn == 1
+        if (y0 < rows)
+        {
+            storepix(x == y0 >> 2 ? (T)(scalar, 0, 0, 0) : (T)(0), srcptr + src_index);
+            if (++y0 < rows)
+            {
+                src_index += src_step;
+                storepix(x == y0 >> 2 ? (T)(0, scalar, 0, 0) : (T)(0), srcptr + src_index);
+
+                if (++y0 < rows)
+                {
+                    src_index += src_step;
+                    storepix(x == y0 >> 2 ? (T)(0, 0, scalar, 0) : (T)(0), srcptr + src_index);
+
+                    if (++y0 < rows)
+                    {
+                        src_index += src_step;
+                        storepix(x == y0 >> 2 ? (T)(0, 0, 0, scalar) : (T)(0), srcptr + src_index);
+                    }
+                }
+            }
+        }
+#else
+#error "Incorrect combination of cn && kercn"
+#endif
     }
 }

modules/core/src/stat.cpp

@@ -918,8 +918,14 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
         int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
         bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0,
                 isContinuous = _src.isContinuous();
-        int groups = ocl::Device::getDefault().maxComputeUnits();
+        const ocl::Device &defDev = ocl::Device::getDefault();
-        size_t wgs = ocl::Device::getDefault().maxWorkGroupSize();
+        int groups = defDev.maxComputeUnits();
+        if (defDev.isIntel())
+        {
+            static const int subSliceEUCount = 10;
+            groups = (groups / subSliceEUCount) * 2;
+        }
+        size_t wgs = defDev.maxWorkGroupSize();
 
         int ddepth = std::max(CV_32S, depth), sqddepth = std::max(CV_32F, depth),
                 dtype = CV_MAKE_TYPE(ddepth, cn),

modules/cudacodec/CMakeLists.txt

@@ -6,7 +6,7 @@ set(the_description "CUDA-accelerated Video Encoding/Decoding")
 
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef)
 
-ocv_add_module(cudacodec opencv_highgui OPTIONAL opencv_cudev)
+ocv_add_module(cudacodec OPTIONAL opencv_cudev)
 
 ocv_module_include_directories()
 ocv_glob_module_sources()

modules/cudev/test/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(test_deps opencv_cudev opencv_core opencv_imgproc opencv_highgui opencv_ts ${OPENCV_MODULE_opencv_ts_DEPS})
+set(test_deps opencv_cudev opencv_core opencv_imgproc opencv_imgcodecs opencv_videoio opencv_highgui opencv_ts ${OPENCV_MODULE_opencv_ts_DEPS})
 
 ocv_check_dependencies(${test_deps})
 

modules/features2d/perf/perf_precomp.hpp

@@ -10,7 +10,7 @@
 #define __OPENCV_PERF_PRECOMP_HPP__
 
 #include "opencv2/ts.hpp"
-#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
 #include "opencv2/features2d.hpp"
 
 #ifdef GTEST_CREATE_SHARED_LIBRARY

modules/features2d/test/test_descriptors_regression.cpp

@@ -40,7 +40,6 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include "opencv2/highgui.hpp"
 
 using namespace std;
 using namespace cv;

modules/features2d/test/test_precomp.hpp

@@ -12,7 +12,7 @@
 #include "opencv2/ts.hpp"
 #include "opencv2/imgproc.hpp"
 #include "opencv2/features2d.hpp"
-#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
 #include <iostream>
 
 #endif

modules/flann/include/opencv2/flann/dist.h

@@ -595,7 +595,7 @@ struct HellingerDistance
     typedef typename Accumulator<T>::Type ResultType;
 
     /**
-     *  Compute the histogram intersection distance
+     *  Compute the Hellinger distance
      */
     template <typename Iterator1, typename Iterator2>
     ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const
@@ -628,7 +628,8 @@ struct HellingerDistance
     template <typename U, typename V>
     inline ResultType accum_dist(const U& a, const V& b, int) const
     {
-        return sqrt(static_cast<ResultType>(a)) - sqrt(static_cast<ResultType>(b));
+        ResultType diff = sqrt(static_cast<ResultType>(a)) - sqrt(static_cast<ResultType>(b));
+        return diff * diff;
     }
 };
 
@@ -729,9 +730,11 @@ struct KL_Divergence
     inline ResultType accum_dist(const U& a, const V& b, int) const
     {
         ResultType result = ResultType();
-        ResultType ratio = (ResultType)(a / b);
+        if( *b != 0 ) {
-        if (ratio>0) {
+            ResultType ratio = (ResultType)(a / b);
-            result = a * log(ratio);
+            if (ratio>0) {
+                result = a * log(ratio);
+            }
         }
         return result;
     }

modules/highgui/CMakeLists.txt

@@ -1,5 +1,5 @@
 set(the_description "High-level GUI and Media I/O")
-ocv_add_module(highgui opencv_imgproc OPTIONAL opencv_androidcamera)
+ocv_add_module(highgui opencv_imgproc opencv_imgcodecs opencv_videoio OPTIONAL opencv_androidcamera)
 
 # ----------------------------------------------------------------------------
 #  CMake file for highgui. See root CMakeLists.txt
@@ -7,70 +7,20 @@ ocv_add_module(highgui opencv_imgproc OPTIONAL opencv_androidcamera)
 #   Jose Luis Blanco, 2008
 # ----------------------------------------------------------------------------
 
-ocv_clear_vars(GRFMT_LIBS)
-
 if(HAVE_WINRT_CX)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /ZW")
 endif()
 
-if(HAVE_PNG OR HAVE_TIFF OR HAVE_OPENEXR)
+if(APPLE)
   ocv_include_directories(${ZLIB_INCLUDE_DIRS})
-  list(APPEND GRFMT_LIBS ${ZLIB_LIBRARIES})
+  list(APPEND HIGHGUI_LIBRARIES ${ZLIB_LIBRARIES})
 endif()
 
-if(HAVE_JPEG)
-  ocv_include_directories(${JPEG_INCLUDE_DIR})
-  list(APPEND GRFMT_LIBS ${JPEG_LIBRARIES})
-endif()
-
-if(WITH_WEBP)
-  add_definitions(-DHAVE_WEBP)
-  ocv_include_directories(${WEBP_INCLUDE_DIR})
-  list(APPEND GRFMT_LIBS ${WEBP_LIBRARIES})
-endif()
-
-if(HAVE_PNG)
-  add_definitions(${PNG_DEFINITIONS})
-  ocv_include_directories(${PNG_INCLUDE_DIR})
-  list(APPEND GRFMT_LIBS ${PNG_LIBRARIES})
-endif()
-
-if(HAVE_TIFF)
-  ocv_include_directories(${TIFF_INCLUDE_DIR})
-  list(APPEND GRFMT_LIBS ${TIFF_LIBRARIES})
-endif()
-
-if(HAVE_JASPER)
-  ocv_include_directories(${JASPER_INCLUDE_DIR})
-  list(APPEND GRFMT_LIBS ${JASPER_LIBRARIES})
-endif()
-
-if(HAVE_OPENEXR)
-  include_directories(SYSTEM ${OPENEXR_INCLUDE_PATHS})
-  list(APPEND GRFMT_LIBS ${OPENEXR_LIBRARIES})
-endif()
-
-file(GLOB grfmt_hdrs src/grfmt*.hpp)
-file(GLOB grfmt_srcs src/grfmt*.cpp)
-list(APPEND grfmt_hdrs src/bitstrm.hpp)
-list(APPEND grfmt_srcs src/bitstrm.cpp)
-list(APPEND grfmt_hdrs src/rgbe.hpp)
-list(APPEND grfmt_srcs src/rgbe.cpp)
-
-source_group("Src\\grfmts" FILES ${grfmt_hdrs} ${grfmt_srcs})
-
 set(highgui_hdrs
     src/precomp.hpp
-    src/utils.hpp
-    src/cap_ffmpeg_impl.hpp
     )
 
 set(highgui_srcs
-    src/cap.cpp
-    src/cap_images.cpp
-    src/cap_ffmpeg.cpp
-    src/loadsave.cpp
-    src/utils.cpp
     src/window.cpp
     )
 
@@ -122,128 +72,6 @@ elseif(HAVE_COCOA)
   list(APPEND HIGHGUI_LIBRARIES "-framework Cocoa")
 endif()
 
-if(WIN32 AND NOT ARM)
-  list(APPEND highgui_srcs src/cap_cmu.cpp)
-endif()
-
-if (WIN32 AND HAVE_DSHOW)
-  list(APPEND highgui_srcs src/cap_dshow.cpp)
-endif()
-
-if (WIN32 AND HAVE_MSMF)
-  list(APPEND highgui_srcs src/cap_msmf.cpp)
-endif()
-
-if (WIN32 AND HAVE_VFW)
-  list(APPEND highgui_srcs src/cap_vfw.cpp)
-endif()
-
-if(HAVE_XINE)
-  list(APPEND highgui_srcs src/cap_xine.cpp)
-endif(HAVE_XINE)
-
-if(HAVE_DC1394_2)
-  list(APPEND highgui_srcs src/cap_dc1394_v2.cpp)
-endif(HAVE_DC1394_2)
-
-if(HAVE_DC1394)
-  list(APPEND highgui_srcs src/cap_dc1394.cpp)
-endif(HAVE_DC1394)
-
-if(HAVE_GSTREAMER)
-  list(APPEND highgui_srcs src/cap_gstreamer.cpp)
-endif(HAVE_GSTREAMER)
-
-if(HAVE_UNICAP)
-  list(APPEND highgui_srcs src/cap_unicap.cpp)
-endif(HAVE_UNICAP)
-
-if(HAVE_LIBV4L)
-  list(APPEND highgui_srcs src/cap_libv4l.cpp)
-elseif(HAVE_CAMV4L OR HAVE_CAMV4L2 OR HAVE_VIDEOIO)
-  list(APPEND highgui_srcs src/cap_v4l.cpp)
-endif()
-
-if(HAVE_OPENNI)
-  list(APPEND highgui_srcs src/cap_openni.cpp)
-  ocv_include_directories(${OPENNI_INCLUDE_DIR})
-  list(APPEND HIGHGUI_LIBRARIES ${OPENNI_LIBRARY})
-endif(HAVE_OPENNI)
-
-if(HAVE_opencv_androidcamera)
-  list(APPEND highgui_srcs src/cap_android.cpp)
-  add_definitions(-DHAVE_ANDROID_NATIVE_CAMERA)#TODO: remove this line
-endif(HAVE_opencv_androidcamera)
-
-if(HAVE_XIMEA)
-  list(APPEND highgui_srcs src/cap_ximea.cpp)
-  ocv_include_directories(${XIMEA_PATH})
-  if(XIMEA_LIBRARY_DIR)
-    link_directories("${XIMEA_LIBRARY_DIR}")
-  endif()
-  if(X86_64)
-    list(APPEND HIGHGUI_LIBRARIES m3apiX64)
-  else()
-    list(APPEND HIGHGUI_LIBRARIES m3api)
-  endif()
-endif(HAVE_XIMEA)
-
-if(HAVE_FFMPEG)
-  if(UNIX AND BZIP2_LIBRARIES)
-    list(APPEND HIGHGUI_LIBRARIES ${BZIP2_LIBRARIES})
-  endif()
-  if(APPLE)
-    list(APPEND HIGHGUI_LIBRARIES "-framework VideoDecodeAcceleration" bz2)
-  endif()
-endif(HAVE_FFMPEG)
-
-if(HAVE_PVAPI)
-  add_definitions(-DHAVE_PVAPI)
-  add_definitions(${PVAPI_DEFINITIONS})
-  ocv_include_directories(${PVAPI_INCLUDE_PATH})
-  set(highgui_srcs src/cap_pvapi.cpp ${highgui_srcs})
-  list(APPEND HIGHGUI_LIBRARIES ${PVAPI_LIBRARY})
-endif()
-
-if(HAVE_GIGE_API)
-  add_definitions(-DHAVE_GIGE_API)
-  ocv_include_directories(${GIGEAPI_INCLUDE_PATH})
-  set(highgui_srcs src/cap_giganetix.cpp ${highgui_srcs})
-  list(APPEND HIGHGUI_LIBRARIES ${GIGEAPI_LIBRARIES})
-  list(APPEND highgui_srcs src/cap_giganetix.cpp)
-endif(HAVE_GIGE_API)
-
-if(HAVE_AVFOUNDATION)
-  list(APPEND highgui_srcs src/cap_avfoundation.mm)
-  list(APPEND HIGHGUI_LIBRARIES "-framework AVFoundation" "-framework QuartzCore")
-endif()
-
-if(HAVE_QUICKTIME)
-  list(APPEND highgui_srcs src/cap_qt.cpp)
-  list(APPEND HIGHGUI_LIBRARIES "-framework Carbon" "-framework QuickTime" "-framework CoreFoundation" "-framework QuartzCore")
-elseif(HAVE_QTKIT)
-  list(APPEND highgui_srcs src/cap_qtkit.mm)
-  list(APPEND HIGHGUI_LIBRARIES "-framework QTKit" "-framework QuartzCore" "-framework AppKit")
-endif()
-
-if(HAVE_INTELPERC)
-  list(APPEND highgui_srcs src/cap_intelperc.cpp)
-  ocv_include_directories(${INTELPERC_INCLUDE_DIR})
-  list(APPEND HIGHGUI_LIBRARIES ${INTELPERC_LIBRARIES})
-endif(HAVE_INTELPERC)
-
-if(IOS)
-  add_definitions(-DHAVE_IOS=1)
-  list(APPEND highgui_srcs src/ios_conversions.mm src/cap_ios_abstract_camera.mm src/cap_ios_photo_camera.mm src/cap_ios_video_camera.mm)
-  list(APPEND HIGHGUI_LIBRARIES "-framework Accelerate" "-framework AVFoundation" "-framework CoreGraphics" "-framework CoreImage" "-framework CoreMedia" "-framework CoreVideo" "-framework QuartzCore" "-framework AssetsLibrary")
-endif()
-
-if(WIN32)
-  link_directories("${OpenCV_SOURCE_DIR}/3rdparty/lib") # for ffmpeg wrapper only
-  include_directories(AFTER SYSTEM "${OpenCV_SOURCE_DIR}/3rdparty/include") # for directshow in VS2005 and multi-monitor support on MinGW
-  include_directories(AFTER SYSTEM "${OpenCV_SOURCE_DIR}/3rdparty/include/ffmpeg_") # for tests
-endif()
-
 if(UNIX)
   #these variables are set by CHECK_MODULE macro
   foreach(P ${HIGHGUI_INCLUDE_DIRS})
@@ -257,10 +85,10 @@ endif()
 
 source_group("Src" FILES ${highgui_srcs} ${highgui_hdrs})
 source_group("Include" FILES ${highgui_ext_hdrs})
-ocv_set_module_sources(HEADERS ${highgui_ext_hdrs} SOURCES ${highgui_srcs} ${highgui_hdrs} ${grfmt_srcs} ${grfmt_hdrs})
+ocv_set_module_sources(HEADERS ${highgui_ext_hdrs} SOURCES ${highgui_srcs} ${highgui_hdrs})
 ocv_module_include_directories()
 
-ocv_create_module(${GRFMT_LIBS} ${HIGHGUI_LIBRARIES})
+ocv_create_module(${HIGHGUI_LIBRARIES})
 
 if(APPLE)
   ocv_check_flag_support(OBJCXX "-fobjc-exceptions" HAVE_OBJC_EXCEPTIONS)
@@ -294,33 +122,5 @@ set_target_properties(${the_module} PROPERTIES LINK_INTERFACE_LIBRARIES "")
 ocv_add_precompiled_headers(${the_module})
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-deprecated-declarations)
 
-if(WIN32 AND WITH_FFMPEG)
-  #copy ffmpeg dll to the output folder
-  if(MSVC64 OR MINGW64)
-    set(FFMPEG_SUFFIX _64)
-  endif()
-
-  set(ffmpeg_bare_name "opencv_ffmpeg${FFMPEG_SUFFIX}.dll")
-  set(ffmpeg_bare_name_ver "opencv_ffmpeg${OPENCV_DLLVERSION}${FFMPEG_SUFFIX}.dll")
-  set(ffmpeg_path "${OpenCV_SOURCE_DIR}/3rdparty/ffmpeg/${ffmpeg_bare_name}")
-
-  if(MSVC_IDE)
-    add_custom_command(TARGET ${the_module} POST_BUILD
-                       COMMAND ${CMAKE_COMMAND} -E copy "${ffmpeg_path}" "${EXECUTABLE_OUTPUT_PATH}/Release/${ffmpeg_bare_name_ver}"
-                       COMMAND ${CMAKE_COMMAND} -E copy "${ffmpeg_path}" "${EXECUTABLE_OUTPUT_PATH}/Debug/${ffmpeg_bare_name_ver}"
-                       COMMENT "Copying ${ffmpeg_path} to the output directory")
-  elseif(MSVC AND (CMAKE_GENERATOR MATCHES "Visual"))
-    add_custom_command(TARGET ${the_module} POST_BUILD
-                       COMMAND ${CMAKE_COMMAND} -E copy "${ffmpeg_path}" "${EXECUTABLE_OUTPUT_PATH}/${CMAKE_BUILD_TYPE}/${ffmpeg_bare_name_ver}"
-                       COMMENT "Copying ${ffmpeg_path} to the output directory")
-  else()
-    add_custom_command(TARGET ${the_module} POST_BUILD
-                       COMMAND ${CMAKE_COMMAND} -E copy "${ffmpeg_path}" "${EXECUTABLE_OUTPUT_PATH}/${ffmpeg_bare_name_ver}"
-                       COMMENT "Copying ${ffmpeg_path} to the output directory")
-  endif()
-
-  install(FILES "${ffmpeg_path}" DESTINATION ${OPENCV_BIN_INSTALL_PATH} COMPONENT libs RENAME "${ffmpeg_bare_name_ver}")
-endif()
-
 ocv_add_accuracy_tests()
 ocv_add_perf_tests()

modules/highgui/doc/highgui.rst

@@ -9,12 +9,9 @@ It provides easy interface to:
 
 * Create and manipulate windows that can display images and "remember" their content (no need to handle repaint events from OS).
 * Add trackbars to the windows, handle simple mouse events as well as keyboard commands.
-* Read and write images to/from disk or memory.
-* Read video from camera or file and write video to a file.
 
 .. toctree::
     :maxdepth: 2
 
     user_interface
-    reading_and_writing_images_and_video
     qt_new_functions

modules/highgui/include/opencv2/highgui.hpp

@@ -44,6 +44,8 @@
 #define __OPENCV_HIGHGUI_HPP__
 
 #include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/videoio.hpp"
 
 
 ///////////////////////// graphical user interface //////////////////////////
@@ -201,392 +203,4 @@ CV_EXPORTS int createButton( const String& bar_name, ButtonCallback on_change,
                              bool initial_button_state = false);
 
 } // cv
-
-
-
-//////////////////////////////// image codec ////////////////////////////////
-namespace cv
-{
-
-enum { IMREAD_UNCHANGED  = -1, // 8bit, color or not
-       IMREAD_GRAYSCALE  = 0,  // 8bit, gray
-       IMREAD_COLOR      = 1,  // ?, color
-       IMREAD_ANYDEPTH   = 2,  // any depth, ?
-       IMREAD_ANYCOLOR   = 4   // ?, any color
-     };
-
-enum { IMWRITE_JPEG_QUALITY     = 1,
-       IMWRITE_JPEG_PROGRESSIVE = 2,
-       IMWRITE_JPEG_OPTIMIZE    = 3,
-       IMWRITE_PNG_COMPRESSION  = 16,
-       IMWRITE_PNG_STRATEGY     = 17,
-       IMWRITE_PNG_BILEVEL      = 18,
-       IMWRITE_PXM_BINARY       = 32,
-       IMWRITE_WEBP_QUALITY     = 64
-     };
-
-enum { IMWRITE_PNG_STRATEGY_DEFAULT      = 0,
-       IMWRITE_PNG_STRATEGY_FILTERED     = 1,
-       IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2,
-       IMWRITE_PNG_STRATEGY_RLE          = 3,
-       IMWRITE_PNG_STRATEGY_FIXED        = 4
-     };
-
-CV_EXPORTS_W Mat imread( const String& filename, int flags = IMREAD_COLOR );
-
-CV_EXPORTS_W bool imwrite( const String& filename, InputArray img,
-              const std::vector<int>& params = std::vector<int>());
-
-CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );
-
-CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst);
-
-CV_EXPORTS_W bool imencode( const String& ext, InputArray img,
-                            CV_OUT std::vector<uchar>& buf,
-                            const std::vector<int>& params = std::vector<int>());
-
-} // cv
-
-
-
-////////////////////////////////// video io /////////////////////////////////
-
-typedef struct CvCapture CvCapture;
-typedef struct CvVideoWriter CvVideoWriter;
-
-namespace cv
-{
-
-// Camera API
-enum { CAP_ANY          = 0,     // autodetect
-       CAP_VFW          = 200,   // platform native
-       CAP_V4L          = 200,
-       CAP_V4L2         = CAP_V4L,
-       CAP_FIREWARE     = 300,   // IEEE 1394 drivers
-       CAP_FIREWIRE     = CAP_FIREWARE,
-       CAP_IEEE1394     = CAP_FIREWARE,
-       CAP_DC1394       = CAP_FIREWARE,
-       CAP_CMU1394      = CAP_FIREWARE,
-       CAP_QT           = 500,   // QuickTime
-       CAP_UNICAP       = 600,   // Unicap drivers
-       CAP_DSHOW        = 700,   // DirectShow (via videoInput)
-       CAP_PVAPI        = 800,   // PvAPI, Prosilica GigE SDK
-       CAP_OPENNI       = 900,   // OpenNI (for Kinect)
-       CAP_OPENNI_ASUS  = 910,   // OpenNI (for Asus Xtion)
-       CAP_ANDROID      = 1000,  // Android
-       CAP_XIAPI        = 1100,  // XIMEA Camera API
-       CAP_AVFOUNDATION = 1200,  // AVFoundation framework for iOS (OS X Lion will have the same API)
-       CAP_GIGANETIX    = 1300,  // Smartek Giganetix GigEVisionSDK
-       CAP_MSMF         = 1400,  // Microsoft Media Foundation (via videoInput)
-       CAP_INTELPERC    = 1500   // Intel Perceptual Computing SDK
-     };
-
-// generic properties (based on DC1394 properties)
-enum { CAP_PROP_POS_MSEC       =0,
-       CAP_PROP_POS_FRAMES     =1,
-       CAP_PROP_POS_AVI_RATIO  =2,
-       CAP_PROP_FRAME_WIDTH    =3,
-       CAP_PROP_FRAME_HEIGHT   =4,
-       CAP_PROP_FPS            =5,
-       CAP_PROP_FOURCC         =6,
-       CAP_PROP_FRAME_COUNT    =7,
-       CAP_PROP_FORMAT         =8,
-       CAP_PROP_MODE           =9,
-       CAP_PROP_BRIGHTNESS    =10,
-       CAP_PROP_CONTRAST      =11,
-       CAP_PROP_SATURATION    =12,
-       CAP_PROP_HUE           =13,
-       CAP_PROP_GAIN          =14,
-       CAP_PROP_EXPOSURE      =15,
-       CAP_PROP_CONVERT_RGB   =16,
-       CAP_PROP_WHITE_BALANCE_BLUE_U =17,
-       CAP_PROP_RECTIFICATION =18,
-       CAP_PROP_MONOCROME     =19,
-       CAP_PROP_SHARPNESS     =20,
-       CAP_PROP_AUTO_EXPOSURE =21, // DC1394: exposure control done by camera, user can adjust refernce level using this feature
-       CAP_PROP_GAMMA         =22,
-       CAP_PROP_TEMPERATURE   =23,
-       CAP_PROP_TRIGGER       =24,
-       CAP_PROP_TRIGGER_DELAY =25,
-       CAP_PROP_WHITE_BALANCE_RED_V =26,
-       CAP_PROP_ZOOM          =27,
-       CAP_PROP_FOCUS         =28,
-       CAP_PROP_GUID          =29,
-       CAP_PROP_ISO_SPEED     =30,
-       CAP_PROP_BACKLIGHT     =32,
-       CAP_PROP_PAN           =33,
-       CAP_PROP_TILT          =34,
-       CAP_PROP_ROLL          =35,
-       CAP_PROP_IRIS          =36,
-       CAP_PROP_SETTINGS      =37
-     };
-
-
-// DC1394 only
-// modes of the controlling registers (can be: auto, manual, auto single push, absolute Latter allowed with any other mode)
-// every feature can have only one mode turned on at a time
-enum { CAP_PROP_DC1394_OFF                = -4, //turn the feature off (not controlled manually nor automatically)
-       CAP_PROP_DC1394_MODE_MANUAL        = -3, //set automatically when a value of the feature is set by the user
-       CAP_PROP_DC1394_MODE_AUTO          = -2,
-       CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
-       CAP_PROP_DC1394_MAX                = 31
-     };
-
-
-// OpenNI map generators
-enum { CAP_OPENNI_DEPTH_GENERATOR = 1 << 31,
-       CAP_OPENNI_IMAGE_GENERATOR = 1 << 30,
-       CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR
-     };
-
-// Properties of cameras available through OpenNI interfaces
-enum { CAP_PROP_OPENNI_OUTPUT_MODE       = 100,
-       CAP_PROP_OPENNI_FRAME_MAX_DEPTH   = 101, // in mm
-       CAP_PROP_OPENNI_BASELINE          = 102, // in mm
-       CAP_PROP_OPENNI_FOCAL_LENGTH      = 103, // in pixels
-       CAP_PROP_OPENNI_REGISTRATION      = 104, // flag that synchronizes the remapping depth map to image map
-                                                // by changing depth generator's view point (if the flag is "on") or
-                                                // sets this view point to its normal one (if the flag is "off").
-       CAP_PROP_OPENNI_REGISTRATION_ON   = CAP_PROP_OPENNI_REGISTRATION,
-       CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105,
-       CAP_PROP_OPENNI_MAX_BUFFER_SIZE   = 106,
-       CAP_PROP_OPENNI_CIRCLE_BUFFER     = 107,
-       CAP_PROP_OPENNI_MAX_TIME_DURATION = 108,
-       CAP_PROP_OPENNI_GENERATOR_PRESENT = 109
-     };
-
-// OpenNI shortcats
-enum { CAP_OPENNI_IMAGE_GENERATOR_PRESENT         = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT,
-       CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE     = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE,
-       CAP_OPENNI_DEPTH_GENERATOR_BASELINE        = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE,
-       CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH    = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH,
-       CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION    = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION,
-       CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION
-     };
-
-// OpenNI data given from depth generator
-enum { CAP_OPENNI_DEPTH_MAP         = 0, // Depth values in mm (CV_16UC1)
-       CAP_OPENNI_POINT_CLOUD_MAP   = 1, // XYZ in meters (CV_32FC3)
-       CAP_OPENNI_DISPARITY_MAP     = 2, // Disparity in pixels (CV_8UC1)
-       CAP_OPENNI_DISPARITY_MAP_32F = 3, // Disparity in pixels (CV_32FC1)
-       CAP_OPENNI_VALID_DEPTH_MASK  = 4, // CV_8UC1
-
-       // Data given from RGB image generator
-       CAP_OPENNI_BGR_IMAGE         = 5,
-       CAP_OPENNI_GRAY_IMAGE        = 6
-     };
-
-// Supported output modes of OpenNI image generator
-enum { CAP_OPENNI_VGA_30HZ  = 0,
-       CAP_OPENNI_SXGA_15HZ = 1,
-       CAP_OPENNI_SXGA_30HZ = 2,
-       CAP_OPENNI_QVGA_30HZ = 3,
-       CAP_OPENNI_QVGA_60HZ = 4
-     };
-
-
-// GStreamer
-enum { CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200 // default is 1
-     };
-
-
-// PVAPI
-enum { CAP_PROP_PVAPI_MULTICASTIP               = 300, // ip for anable multicast master mode. 0 for disable multicast
-       CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE     = 301  // FrameStartTriggerMode: Determines how a frame is initiated
-     };
-
-// PVAPI: FrameStartTriggerMode
-enum { CAP_PVAPI_FSTRIGMODE_FREERUN     = 0,    // Freerun
-       CAP_PVAPI_FSTRIGMODE_SYNCIN1     = 1,    // SyncIn1
-       CAP_PVAPI_FSTRIGMODE_SYNCIN2     = 2,    // SyncIn2
-       CAP_PVAPI_FSTRIGMODE_FIXEDRATE   = 3,    // FixedRate
-       CAP_PVAPI_FSTRIGMODE_SOFTWARE    = 4     // Software
-     };
-
-// Properties of cameras available through XIMEA SDK interface
-enum { CAP_PROP_XI_DOWNSAMPLING  = 400, // Change image resolution by binning or skipping.
-       CAP_PROP_XI_DATA_FORMAT   = 401, // Output data format.
-       CAP_PROP_XI_OFFSET_X      = 402, // Horizontal offset from the origin to the area of interest (in pixels).
-       CAP_PROP_XI_OFFSET_Y      = 403, // Vertical offset from the origin to the area of interest (in pixels).
-       CAP_PROP_XI_TRG_SOURCE    = 404, // Defines source of trigger.
-       CAP_PROP_XI_TRG_SOFTWARE  = 405, // Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
-       CAP_PROP_XI_GPI_SELECTOR  = 406, // Selects general purpose input
-       CAP_PROP_XI_GPI_MODE      = 407, // Set general purpose input mode
-       CAP_PROP_XI_GPI_LEVEL     = 408, // Get general purpose level
-       CAP_PROP_XI_GPO_SELECTOR  = 409, // Selects general purpose output
-       CAP_PROP_XI_GPO_MODE      = 410, // Set general purpose output mode
-       CAP_PROP_XI_LED_SELECTOR  = 411, // Selects camera signalling LED
-       CAP_PROP_XI_LED_MODE      = 412, // Define camera signalling LED functionality
-       CAP_PROP_XI_MANUAL_WB     = 413, // Calculates White Balance(must be called during acquisition)
-       CAP_PROP_XI_AUTO_WB       = 414, // Automatic white balance
-       CAP_PROP_XI_AEAG          = 415, // Automatic exposure/gain
-       CAP_PROP_XI_EXP_PRIORITY  = 416, // Exposure priority (0.5 - exposure 50%, gain 50%).
-       CAP_PROP_XI_AE_MAX_LIMIT  = 417, // Maximum limit of exposure in AEAG procedure
-       CAP_PROP_XI_AG_MAX_LIMIT  = 418, // Maximum limit of gain in AEAG procedure
-       CAP_PROP_XI_AEAG_LEVEL    = 419, // Average intensity of output signal AEAG should achieve(in %)
-       CAP_PROP_XI_TIMEOUT       = 420  // Image capture timeout in milliseconds
-     };
-
-
-// Properties for Android cameras
-enum { CAP_PROP_ANDROID_AUTOGRAB               = 1024,
-       CAP_PROP_ANDROID_PREVIEW_SIZES_STRING   = 1025, // readonly, tricky property, returns const char* indeed
-       CAP_PROP_ANDROID_PREVIEW_FORMAT         = 1026, // readonly, tricky property, returns const char* indeed
-       CAP_PROP_ANDROID_FLASH_MODE             = 8001,
-       CAP_PROP_ANDROID_FOCUS_MODE             = 8002,
-       CAP_PROP_ANDROID_WHITE_BALANCE          = 8003,
-       CAP_PROP_ANDROID_ANTIBANDING            = 8004,
-       CAP_PROP_ANDROID_FOCAL_LENGTH           = 8005,
-       CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR    = 8006,
-       CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007,
-       CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR     = 8008
-     };
-
-
-// Android camera output formats
-enum { CAP_ANDROID_COLOR_FRAME_BGR  = 0, //BGR
-       CAP_ANDROID_COLOR_FRAME      = CAP_ANDROID_COLOR_FRAME_BGR,
-       CAP_ANDROID_GREY_FRAME       = 1,  //Y
-       CAP_ANDROID_COLOR_FRAME_RGB  = 2,
-       CAP_ANDROID_COLOR_FRAME_BGRA = 3,
-       CAP_ANDROID_COLOR_FRAME_RGBA = 4
-     };
-
-
-// Android camera flash modes
-enum { CAP_ANDROID_FLASH_MODE_AUTO     = 0,
-       CAP_ANDROID_FLASH_MODE_OFF      = 1,
-       CAP_ANDROID_FLASH_MODE_ON       = 2,
-       CAP_ANDROID_FLASH_MODE_RED_EYE  = 3,
-       CAP_ANDROID_FLASH_MODE_TORCH    = 4
-     };
-
-
-// Android camera focus modes
-enum { CAP_ANDROID_FOCUS_MODE_AUTO             = 0,
-       CAP_ANDROID_FOCUS_MODE_CONTINUOUS_VIDEO = 1,
-       CAP_ANDROID_FOCUS_MODE_EDOF             = 2,
-       CAP_ANDROID_FOCUS_MODE_FIXED            = 3,
-       CAP_ANDROID_FOCUS_MODE_INFINITY         = 4,
-       CAP_ANDROID_FOCUS_MODE_MACRO            = 5
-     };
-
-
-// Android camera white balance modes
-enum { CAP_ANDROID_WHITE_BALANCE_AUTO             = 0,
-       CAP_ANDROID_WHITE_BALANCE_CLOUDY_DAYLIGHT  = 1,
-       CAP_ANDROID_WHITE_BALANCE_DAYLIGHT         = 2,
-       CAP_ANDROID_WHITE_BALANCE_FLUORESCENT      = 3,
-       CAP_ANDROID_WHITE_BALANCE_INCANDESCENT     = 4,
-       CAP_ANDROID_WHITE_BALANCE_SHADE            = 5,
-       CAP_ANDROID_WHITE_BALANCE_TWILIGHT         = 6,
-       CAP_ANDROID_WHITE_BALANCE_WARM_FLUORESCENT = 7
-     };
-
-
-// Android camera antibanding modes
-enum { CAP_ANDROID_ANTIBANDING_50HZ = 0,
-       CAP_ANDROID_ANTIBANDING_60HZ = 1,
-       CAP_ANDROID_ANTIBANDING_AUTO = 2,
-       CAP_ANDROID_ANTIBANDING_OFF  = 3
-     };
-
-
-// Properties of cameras available through AVFOUNDATION interface
-enum { CAP_PROP_IOS_DEVICE_FOCUS        = 9001,
-       CAP_PROP_IOS_DEVICE_EXPOSURE     = 9002,
-       CAP_PROP_IOS_DEVICE_FLASH        = 9003,
-       CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
-       CAP_PROP_IOS_DEVICE_TORCH        = 9005
-     };
-
-
-// Properties of cameras available through Smartek Giganetix Ethernet Vision interface
-/* --- Vladimir Litvinenko (litvinenko.vladimir@gmail.com) --- */
-enum { CAP_PROP_GIGA_FRAME_OFFSET_X   = 10001,
-       CAP_PROP_GIGA_FRAME_OFFSET_Y   = 10002,
-       CAP_PROP_GIGA_FRAME_WIDTH_MAX  = 10003,
-       CAP_PROP_GIGA_FRAME_HEIGH_MAX  = 10004,
-       CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
-       CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006
-     };
-
-enum { CAP_PROP_INTELPERC_PROFILE_COUNT               = 11001,
-       CAP_PROP_INTELPERC_PROFILE_IDX                 = 11002,
-       CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE  = 11003,
-       CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE      = 11004,
-       CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD  = 11005,
-       CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ     = 11006,
-       CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT     = 11007
-     };
-
-// Intel PerC streams
-enum { CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29,
-       CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28,
-       CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR
-     };
-
-enum { CAP_INTELPERC_DEPTH_MAP              = 0, // Each pixel is a 16-bit integer. The value indicates the distance from an object to the camera's XY plane or the Cartesian depth.
-       CAP_INTELPERC_UVDEPTH_MAP            = 1, // Each pixel contains two 32-bit floating point values in the range of 0-1, representing the mapping of depth coordinates to the color coordinates.
-       CAP_INTELPERC_IR_MAP                 = 2, // Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam.
-       CAP_INTELPERC_IMAGE                  = 3
-     };
-
-
-class IVideoCapture;
-class CV_EXPORTS_W VideoCapture
-{
-public:
-    CV_WRAP VideoCapture();
-    CV_WRAP VideoCapture(const String& filename);
-    CV_WRAP VideoCapture(int device);
-
-    virtual ~VideoCapture();
-    CV_WRAP virtual bool open(const String& filename);
-    CV_WRAP virtual bool open(int device);
-    CV_WRAP virtual bool isOpened() const;
-    CV_WRAP virtual void release();
-
-    CV_WRAP virtual bool grab();
-    CV_WRAP virtual bool retrieve(OutputArray image, int flag = 0);
-    virtual VideoCapture& operator >> (CV_OUT Mat& image);
-    virtual VideoCapture& operator >> (CV_OUT UMat& image);
-    CV_WRAP virtual bool read(OutputArray image);
-
-    CV_WRAP virtual bool set(int propId, double value);
-    CV_WRAP virtual double get(int propId);
-
-protected:
-    Ptr<CvCapture> cap;
-    Ptr<IVideoCapture> icap;
-private:
-    static Ptr<IVideoCapture> createCameraCapture(int index);
-};
-
-class CV_EXPORTS_W VideoWriter
-{
-public:
-    CV_WRAP VideoWriter();
-    CV_WRAP VideoWriter(const String& filename, int fourcc, double fps,
-                Size frameSize, bool isColor = true);
-
-    virtual ~VideoWriter();
-    CV_WRAP virtual bool open(const String& filename, int fourcc, double fps,
-                      Size frameSize, bool isColor = true);
-    CV_WRAP virtual bool isOpened() const;
-    CV_WRAP virtual void release();
-    virtual VideoWriter& operator << (const Mat& image);
-    CV_WRAP virtual void write(const Mat& image);
-
-    CV_WRAP static int fourcc(char c1, char c2, char c3, char c4);
-
-protected:
-    Ptr<CvVideoWriter> writer;
-};
-
-template<> CV_EXPORTS void DefaultDeleter<CvCapture>::operator ()(CvCapture* obj) const;
-template<> CV_EXPORTS void DefaultDeleter<CvVideoWriter>::operator ()(CvVideoWriter* obj) const;
-
-} // cv
-
 #endif

modules/highgui/include/opencv2/highgui/highgui_c.h

@@ -43,6 +43,8 @@
 #define __OPENCV_HIGHGUI_H__
 
 #include "opencv2/core/core_c.h"
+#include "opencv2/imgcodecs/imgcodecs_c.h"
+#include "opencv2/videoio/videoio_c.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -194,67 +196,6 @@ typedef void (CV_CDECL *CvMouseCallback )(int event, int x, int y, int flags, vo
 CVAPI(void) cvSetMouseCallback( const char* window_name, CvMouseCallback on_mouse,
                                 void* param CV_DEFAULT(NULL));
 
-enum
-{
-/* 8bit, color or not */
-    CV_LOAD_IMAGE_UNCHANGED  =-1,
-/* 8bit, gray */
-    CV_LOAD_IMAGE_GRAYSCALE  =0,
-/* ?, color */
-    CV_LOAD_IMAGE_COLOR      =1,
-/* any depth, ? */
-    CV_LOAD_IMAGE_ANYDEPTH   =2,
-/* ?, any color */
-    CV_LOAD_IMAGE_ANYCOLOR   =4
-};
-
-/* load image from file
-  iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
-  overrides the other flags
-  using CV_LOAD_IMAGE_ANYCOLOR alone is equivalent to CV_LOAD_IMAGE_UNCHANGED
-  unless CV_LOAD_IMAGE_ANYDEPTH is specified images are converted to 8bit
-*/
-CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
-CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
-
-enum
-{
-    CV_IMWRITE_JPEG_QUALITY =1,
-    CV_IMWRITE_JPEG_PROGRESSIVE =2,
-    CV_IMWRITE_JPEG_OPTIMIZE =3,
-    CV_IMWRITE_PNG_COMPRESSION =16,
-    CV_IMWRITE_PNG_STRATEGY =17,
-    CV_IMWRITE_PNG_BILEVEL =18,
-    CV_IMWRITE_PNG_STRATEGY_DEFAULT =0,
-    CV_IMWRITE_PNG_STRATEGY_FILTERED =1,
-    CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY =2,
-    CV_IMWRITE_PNG_STRATEGY_RLE =3,
-    CV_IMWRITE_PNG_STRATEGY_FIXED =4,
-    CV_IMWRITE_PXM_BINARY =32,
-    CV_IMWRITE_WEBP_QUALITY =64
-};
-
-/* save image to file */
-CVAPI(int) cvSaveImage( const char* filename, const CvArr* image,
-                        const int* params CV_DEFAULT(0) );
-
-/* decode image stored in the buffer */
-CVAPI(IplImage*) cvDecodeImage( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
-CVAPI(CvMat*) cvDecodeImageM( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
-
-/* encode image and store the result as a byte vector (single-row 8uC1 matrix) */
-CVAPI(CvMat*) cvEncodeImage( const char* ext, const CvArr* image,
-                             const int* params CV_DEFAULT(0) );
-
-enum
-{
-    CV_CVTIMG_FLIP      =1,
-    CV_CVTIMG_SWAP_RB   =2
-};
-
-/* utility function: convert one image to another with optional vertical flip */
-CVAPI(void) cvConvertImage( const CvArr* src, CvArr* dst, int flags CV_DEFAULT(0));
-
 /* wait for key event infinitely (delay<=0) or for "delay" milliseconds */
 CVAPI(int) cvWaitKey(int delay CV_DEFAULT(0));
 
@@ -268,363 +209,10 @@ CVAPI(void) cvUpdateWindow(const char* window_name);
 
 
 /****************************************************************************************\
-*                         Working with Video Files and Cameras                           *
-\****************************************************************************************/
 
-/* "black box" capture structure */
-typedef struct CvCapture CvCapture;
-
-/* start capturing frames from video file */
-CVAPI(CvCapture*) cvCreateFileCapture( const char* filename );
-
-enum
-{
-    CV_CAP_ANY      =0,     // autodetect
-
-    CV_CAP_MIL      =100,   // MIL proprietary drivers
-
-    CV_CAP_VFW      =200,   // platform native
-    CV_CAP_V4L      =200,
-    CV_CAP_V4L2     =200,
-
-    CV_CAP_FIREWARE =300,   // IEEE 1394 drivers
-    CV_CAP_FIREWIRE =300,
-    CV_CAP_IEEE1394 =300,
-    CV_CAP_DC1394   =300,
-    CV_CAP_CMU1394  =300,
-
-    CV_CAP_STEREO   =400,   // TYZX proprietary drivers
-    CV_CAP_TYZX     =400,
-    CV_TYZX_LEFT    =400,
-    CV_TYZX_RIGHT   =401,
-    CV_TYZX_COLOR   =402,
-    CV_TYZX_Z       =403,
-
-    CV_CAP_QT       =500,   // QuickTime
-
-    CV_CAP_UNICAP   =600,   // Unicap drivers
-
-    CV_CAP_DSHOW    =700,   // DirectShow (via videoInput)
-    CV_CAP_MSMF     =1400,  // Microsoft Media Foundation (via videoInput)
-
-    CV_CAP_PVAPI    =800,   // PvAPI, Prosilica GigE SDK
-
-    CV_CAP_OPENNI   =900,   // OpenNI (for Kinect)
-    CV_CAP_OPENNI_ASUS =910,   // OpenNI (for Asus Xtion)
-
-    CV_CAP_ANDROID  =1000,  // Android
-    CV_CAP_ANDROID_BACK =CV_CAP_ANDROID+99, // Android back camera
-    CV_CAP_ANDROID_FRONT =CV_CAP_ANDROID+98, // Android front camera
-
-    CV_CAP_XIAPI    =1100,   // XIMEA Camera API
-
-    CV_CAP_AVFOUNDATION = 1200,  // AVFoundation framework for iOS (OS X Lion will have the same API)
-
-    CV_CAP_GIGANETIX = 1300,  // Smartek Giganetix GigEVisionSDK
-
-    CV_CAP_INTELPERC = 1500 // Intel Perceptual Computing SDK
-};
-
-/* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*) */
-CVAPI(CvCapture*) cvCreateCameraCapture( int index );
-
-/* grab a frame, return 1 on success, 0 on fail.
-  this function is thought to be fast               */
-CVAPI(int) cvGrabFrame( CvCapture* capture );
-
-/* get the frame grabbed with cvGrabFrame(..)
-  This function may apply some frame processing like
-  frame decompression, flipping etc.
-  !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
-CVAPI(IplImage*) cvRetrieveFrame( CvCapture* capture, int streamIdx CV_DEFAULT(0) );
-
-/* Just a combination of cvGrabFrame and cvRetrieveFrame
-   !!!DO NOT RELEASE or MODIFY the retrieved frame!!!      */
-CVAPI(IplImage*) cvQueryFrame( CvCapture* capture );
-
-/* stop capturing/reading and free resources */
-CVAPI(void) cvReleaseCapture( CvCapture** capture );
-
-enum
-{
-    // modes of the controlling registers (can be: auto, manual, auto single push, absolute Latter allowed with any other mode)
-    // every feature can have only one mode turned on at a time
-    CV_CAP_PROP_DC1394_OFF         = -4,  //turn the feature off (not controlled manually nor automatically)
-    CV_CAP_PROP_DC1394_MODE_MANUAL = -3, //set automatically when a value of the feature is set by the user
-    CV_CAP_PROP_DC1394_MODE_AUTO = -2,
-    CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
-    CV_CAP_PROP_POS_MSEC       =0,
-    CV_CAP_PROP_POS_FRAMES     =1,
-    CV_CAP_PROP_POS_AVI_RATIO  =2,
-    CV_CAP_PROP_FRAME_WIDTH    =3,
-    CV_CAP_PROP_FRAME_HEIGHT   =4,
-    CV_CAP_PROP_FPS            =5,
-    CV_CAP_PROP_FOURCC         =6,
-    CV_CAP_PROP_FRAME_COUNT    =7,
-    CV_CAP_PROP_FORMAT         =8,
-    CV_CAP_PROP_MODE           =9,
-    CV_CAP_PROP_BRIGHTNESS    =10,
-    CV_CAP_PROP_CONTRAST      =11,
-    CV_CAP_PROP_SATURATION    =12,
-    CV_CAP_PROP_HUE           =13,
-    CV_CAP_PROP_GAIN          =14,
-    CV_CAP_PROP_EXPOSURE      =15,
-    CV_CAP_PROP_CONVERT_RGB   =16,
-    CV_CAP_PROP_WHITE_BALANCE_BLUE_U =17,
-    CV_CAP_PROP_RECTIFICATION =18,
-    CV_CAP_PROP_MONOCROME     =19,
-    CV_CAP_PROP_SHARPNESS     =20,
-    CV_CAP_PROP_AUTO_EXPOSURE =21, // exposure control done by camera,
-                                   // user can adjust refernce level
-                                   // using this feature
-    CV_CAP_PROP_GAMMA         =22,
-    CV_CAP_PROP_TEMPERATURE   =23,
-    CV_CAP_PROP_TRIGGER       =24,
-    CV_CAP_PROP_TRIGGER_DELAY =25,
-    CV_CAP_PROP_WHITE_BALANCE_RED_V =26,
-    CV_CAP_PROP_ZOOM          =27,
-    CV_CAP_PROP_FOCUS         =28,
-    CV_CAP_PROP_GUID          =29,
-    CV_CAP_PROP_ISO_SPEED     =30,
-    CV_CAP_PROP_MAX_DC1394    =31,
-    CV_CAP_PROP_BACKLIGHT     =32,
-    CV_CAP_PROP_PAN           =33,
-    CV_CAP_PROP_TILT          =34,
-    CV_CAP_PROP_ROLL          =35,
-    CV_CAP_PROP_IRIS          =36,
-    CV_CAP_PROP_SETTINGS      =37,
-
-    CV_CAP_PROP_AUTOGRAB      =1024, // property for highgui class CvCapture_Android only
-    CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING=1025, // readonly, tricky property, returns cpnst char* indeed
-    CV_CAP_PROP_PREVIEW_FORMAT=1026, // readonly, tricky property, returns cpnst char* indeed
-
-    // OpenNI map generators
-    CV_CAP_OPENNI_DEPTH_GENERATOR = 1 << 31,
-    CV_CAP_OPENNI_IMAGE_GENERATOR = 1 << 30,
-    CV_CAP_OPENNI_GENERATORS_MASK = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_OPENNI_IMAGE_GENERATOR,
-
-    // Properties of cameras available through OpenNI interfaces
-    CV_CAP_PROP_OPENNI_OUTPUT_MODE     = 100,
-    CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, // in mm
-    CV_CAP_PROP_OPENNI_BASELINE        = 102, // in mm
-    CV_CAP_PROP_OPENNI_FOCAL_LENGTH    = 103, // in pixels
-    CV_CAP_PROP_OPENNI_REGISTRATION    = 104, // flag
-    CV_CAP_PROP_OPENNI_REGISTRATION_ON = CV_CAP_PROP_OPENNI_REGISTRATION, // flag that synchronizes the remapping depth map to image map
-                                                                          // by changing depth generator's view point (if the flag is "on") or
-                                                                          // sets this view point to its normal one (if the flag is "off").
-    CV_CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105,
-    CV_CAP_PROP_OPENNI_MAX_BUFFER_SIZE   = 106,
-    CV_CAP_PROP_OPENNI_CIRCLE_BUFFER     = 107,
-    CV_CAP_PROP_OPENNI_MAX_TIME_DURATION = 108,
-
-    CV_CAP_PROP_OPENNI_GENERATOR_PRESENT = 109,
-
-    CV_CAP_OPENNI_IMAGE_GENERATOR_PRESENT         = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT,
-    CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE     = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_OUTPUT_MODE,
-    CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE        = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_BASELINE,
-    CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH    = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_FOCAL_LENGTH,
-    CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION    = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION,
-    CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION,
-
-    // Properties of cameras available through GStreamer interface
-    CV_CAP_GSTREAMER_QUEUE_LENGTH           = 200, // default is 1
-
-    // PVAPI
-    CV_CAP_PROP_PVAPI_MULTICASTIP           = 300, // ip for anable multicast master mode. 0 for disable multicast
-    CV_CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, // FrameStartTriggerMode: Determines how a frame is initiated
-
-    // Properties of cameras available through XIMEA SDK interface
-    CV_CAP_PROP_XI_DOWNSAMPLING  = 400,      // Change image resolution by binning or skipping.
-    CV_CAP_PROP_XI_DATA_FORMAT   = 401,       // Output data format.
-    CV_CAP_PROP_XI_OFFSET_X      = 402,      // Horizontal offset from the origin to the area of interest (in pixels).
-    CV_CAP_PROP_XI_OFFSET_Y      = 403,      // Vertical offset from the origin to the area of interest (in pixels).
-    CV_CAP_PROP_XI_TRG_SOURCE    = 404,      // Defines source of trigger.
-    CV_CAP_PROP_XI_TRG_SOFTWARE  = 405,      // Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
-    CV_CAP_PROP_XI_GPI_SELECTOR  = 406,      // Selects general purpose input
-    CV_CAP_PROP_XI_GPI_MODE      = 407,      // Set general purpose input mode
-    CV_CAP_PROP_XI_GPI_LEVEL     = 408,      // Get general purpose level
-    CV_CAP_PROP_XI_GPO_SELECTOR  = 409,      // Selects general purpose output
-    CV_CAP_PROP_XI_GPO_MODE      = 410,      // Set general purpose output mode
-    CV_CAP_PROP_XI_LED_SELECTOR  = 411,      // Selects camera signalling LED
-    CV_CAP_PROP_XI_LED_MODE      = 412,      // Define camera signalling LED functionality
-    CV_CAP_PROP_XI_MANUAL_WB     = 413,      // Calculates White Balance(must be called during acquisition)
-    CV_CAP_PROP_XI_AUTO_WB       = 414,      // Automatic white balance
-    CV_CAP_PROP_XI_AEAG          = 415,      // Automatic exposure/gain
-    CV_CAP_PROP_XI_EXP_PRIORITY  = 416,      // Exposure priority (0.5 - exposure 50%, gain 50%).
-    CV_CAP_PROP_XI_AE_MAX_LIMIT  = 417,      // Maximum limit of exposure in AEAG procedure
-    CV_CAP_PROP_XI_AG_MAX_LIMIT  = 418,      // Maximum limit of gain in AEAG procedure
-    CV_CAP_PROP_XI_AEAG_LEVEL    = 419,       // Average intensity of output signal AEAG should achieve(in %)
-    CV_CAP_PROP_XI_TIMEOUT       = 420,       // Image capture timeout in milliseconds
-
-    // Properties for Android cameras
-    CV_CAP_PROP_ANDROID_FLASH_MODE = 8001,
-    CV_CAP_PROP_ANDROID_FOCUS_MODE = 8002,
-    CV_CAP_PROP_ANDROID_WHITE_BALANCE = 8003,
-    CV_CAP_PROP_ANDROID_ANTIBANDING = 8004,
-    CV_CAP_PROP_ANDROID_FOCAL_LENGTH = 8005,
-    CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR = 8006,
-    CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007,
-    CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR = 8008,
-    CV_CAP_PROP_ANDROID_EXPOSE_LOCK = 8009,
-    CV_CAP_PROP_ANDROID_WHITEBALANCE_LOCK = 8010,
-
-    // Properties of cameras available through AVFOUNDATION interface
-    CV_CAP_PROP_IOS_DEVICE_FOCUS = 9001,
-    CV_CAP_PROP_IOS_DEVICE_EXPOSURE = 9002,
-    CV_CAP_PROP_IOS_DEVICE_FLASH = 9003,
-    CV_CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004,
-    CV_CAP_PROP_IOS_DEVICE_TORCH = 9005,
-
-    // Properties of cameras available through Smartek Giganetix Ethernet Vision interface
-    /* --- Vladimir Litvinenko (litvinenko.vladimir@gmail.com) --- */
-    CV_CAP_PROP_GIGA_FRAME_OFFSET_X = 10001,
-    CV_CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002,
-    CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003,
-    CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004,
-    CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005,
-    CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006,
-
-    CV_CAP_PROP_INTELPERC_PROFILE_COUNT               = 11001,
-    CV_CAP_PROP_INTELPERC_PROFILE_IDX                 = 11002,
-    CV_CAP_PROP_INTELPERC_DEPTH_LOW_CONFIDENCE_VALUE  = 11003,
-    CV_CAP_PROP_INTELPERC_DEPTH_SATURATION_VALUE      = 11004,
-    CV_CAP_PROP_INTELPERC_DEPTH_CONFIDENCE_THRESHOLD  = 11005,
-    CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_HORZ     = 11006,
-    CV_CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT     = 11007,
-
-    // Intel PerC streams
-    CV_CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29,
-    CV_CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28,
-    CV_CAP_INTELPERC_GENERATORS_MASK = CV_CAP_INTELPERC_DEPTH_GENERATOR + CV_CAP_INTELPERC_IMAGE_GENERATOR
-};
-
-enum
-{
-    // Data given from depth generator.
-    CV_CAP_OPENNI_DEPTH_MAP                 = 0, // Depth values in mm (CV_16UC1)
-    CV_CAP_OPENNI_POINT_CLOUD_MAP           = 1, // XYZ in meters (CV_32FC3)
-    CV_CAP_OPENNI_DISPARITY_MAP             = 2, // Disparity in pixels (CV_8UC1)
-    CV_CAP_OPENNI_DISPARITY_MAP_32F         = 3, // Disparity in pixels (CV_32FC1)
-    CV_CAP_OPENNI_VALID_DEPTH_MASK          = 4, // CV_8UC1
-
-    // Data given from RGB image generator.
-    CV_CAP_OPENNI_BGR_IMAGE                 = 5,
-    CV_CAP_OPENNI_GRAY_IMAGE                = 6
-};
-
-// Supported output modes of OpenNI image generator
-enum
-{
-    CV_CAP_OPENNI_VGA_30HZ     = 0,
-    CV_CAP_OPENNI_SXGA_15HZ    = 1,
-    CV_CAP_OPENNI_SXGA_30HZ    = 2,
-    CV_CAP_OPENNI_QVGA_30HZ    = 3,
-    CV_CAP_OPENNI_QVGA_60HZ    = 4
-};
-
-//supported by Android camera output formats
-enum
-{
-    CV_CAP_ANDROID_COLOR_FRAME_BGR = 0, //BGR
-    CV_CAP_ANDROID_COLOR_FRAME = CV_CAP_ANDROID_COLOR_FRAME_BGR,
-    CV_CAP_ANDROID_GREY_FRAME  = 1,  //Y
-    CV_CAP_ANDROID_COLOR_FRAME_RGB = 2,
-    CV_CAP_ANDROID_COLOR_FRAME_BGRA = 3,
-    CV_CAP_ANDROID_COLOR_FRAME_RGBA = 4
-};
-
-// supported Android camera flash modes
-enum
-{
-    CV_CAP_ANDROID_FLASH_MODE_AUTO = 0,
-    CV_CAP_ANDROID_FLASH_MODE_OFF,
-    CV_CAP_ANDROID_FLASH_MODE_ON,
-    CV_CAP_ANDROID_FLASH_MODE_RED_EYE,
-    CV_CAP_ANDROID_FLASH_MODE_TORCH
-};
-
-// supported Android camera focus modes
-enum
-{
-    CV_CAP_ANDROID_FOCUS_MODE_AUTO = 0,
-    CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_PICTURE,
-    CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_VIDEO,
-    CV_CAP_ANDROID_FOCUS_MODE_EDOF,
-    CV_CAP_ANDROID_FOCUS_MODE_FIXED,
-    CV_CAP_ANDROID_FOCUS_MODE_INFINITY,
-    CV_CAP_ANDROID_FOCUS_MODE_MACRO
-};
-
-// supported Android camera white balance modes
-enum
-{
-    CV_CAP_ANDROID_WHITE_BALANCE_AUTO = 0,
-    CV_CAP_ANDROID_WHITE_BALANCE_CLOUDY_DAYLIGHT,
-    CV_CAP_ANDROID_WHITE_BALANCE_DAYLIGHT,
-    CV_CAP_ANDROID_WHITE_BALANCE_FLUORESCENT,
-    CV_CAP_ANDROID_WHITE_BALANCE_INCANDESCENT,
-    CV_CAP_ANDROID_WHITE_BALANCE_SHADE,
-    CV_CAP_ANDROID_WHITE_BALANCE_TWILIGHT,
-    CV_CAP_ANDROID_WHITE_BALANCE_WARM_FLUORESCENT
-};
-
-// supported Android camera antibanding modes
-enum
-{
-    CV_CAP_ANDROID_ANTIBANDING_50HZ = 0,
-    CV_CAP_ANDROID_ANTIBANDING_60HZ,
-    CV_CAP_ANDROID_ANTIBANDING_AUTO,
-    CV_CAP_ANDROID_ANTIBANDING_OFF
-};
-
-enum
-{
-    CV_CAP_INTELPERC_DEPTH_MAP              = 0, // Each pixel is a 16-bit integer. The value indicates the distance from an object to the camera's XY plane or the Cartesian depth.
-    CV_CAP_INTELPERC_UVDEPTH_MAP            = 1, // Each pixel contains two 32-bit floating point values in the range of 0-1, representing the mapping of depth coordinates to the color coordinates.
-    CV_CAP_INTELPERC_IR_MAP                 = 2, // Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam.
-    CV_CAP_INTELPERC_IMAGE                  = 3
-};
-
-/* retrieve or set capture properties */
-CVAPI(double) cvGetCaptureProperty( CvCapture* capture, int property_id );
-CVAPI(int)    cvSetCaptureProperty( CvCapture* capture, int property_id, double value );
-
-// Return the type of the capturer (eg, CV_CAP_V4W, CV_CAP_UNICAP), which is unknown if created with CV_CAP_ANY
-CVAPI(int)    cvGetCaptureDomain( CvCapture* capture);
-
-/* "black box" video file writer structure */
-typedef struct CvVideoWriter CvVideoWriter;
-
-#define CV_FOURCC_MACRO(c1, c2, c3, c4) (((c1) & 255) + (((c2) & 255) << 8) + (((c3) & 255) << 16) + (((c4) & 255) << 24))
-
-CV_INLINE int CV_FOURCC(char c1, char c2, char c3, char c4)
-{
-    return CV_FOURCC_MACRO(c1, c2, c3, c4);
-}
-
-#define CV_FOURCC_PROMPT -1  /* Open Codec Selection Dialog (Windows only) */
-#define CV_FOURCC_DEFAULT CV_FOURCC('I', 'Y', 'U', 'V') /* Use default codec for specified filename (Linux only) */
-
-/* initialize video file writer */
-CVAPI(CvVideoWriter*) cvCreateVideoWriter( const char* filename, int fourcc,
-                                           double fps, CvSize frame_size,
-                                           int is_color CV_DEFAULT(1));
-
-/* write frame to video file */
-CVAPI(int) cvWriteFrame( CvVideoWriter* writer, const IplImage* image );
-
-/* close video file writer */
-CVAPI(void) cvReleaseVideoWriter( CvVideoWriter** writer );
-
-/****************************************************************************************\
 *                              Obsolete functions/synonyms                               *
 \****************************************************************************************/
 
-#define cvCaptureFromFile cvCreateFileCapture
-#define cvCaptureFromCAM cvCreateCameraCapture
-#define cvCaptureFromAVI cvCaptureFromFile
-#define cvCreateAVIWriter cvCreateVideoWriter
-#define cvWriteToAVI cvWriteFrame
 #define cvAddSearchPath(path)
 #define cvvInitSystem cvInitSystem
 #define cvvNamedWindow cvNamedWindow
@@ -632,12 +220,9 @@ CVAPI(void) cvReleaseVideoWriter( CvVideoWriter** writer );
 #define cvvResizeWindow cvResizeWindow
 #define cvvDestroyWindow cvDestroyWindow
 #define cvvCreateTrackbar cvCreateTrackbar
-#define cvvLoadImage(name) cvLoadImage((name),1)
-#define cvvSaveImage cvSaveImage
 #define cvvAddSearchPath cvAddSearchPath
 #define cvvWaitKey(name) cvWaitKey(0)
 #define cvvWaitKeyEx(name,delay) cvWaitKey(delay)
-#define cvvConvertImage cvConvertImage
 #define HG_AUTOSIZE CV_WINDOW_AUTOSIZE
 #define set_preprocess_func cvSetPreprocessFuncWin32
 #define set_postprocess_func cvSetPostprocessFuncWin32

modules/highgui/src/precomp.hpp

@@ -47,7 +47,10 @@
 #include "opencv2/core/utility.hpp"
 #include "opencv2/core/private.hpp"
 
+#include "opencv2/imgcodecs.hpp"
+
 #include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/imgcodecs/imgcodecs_c.h"
 #include "opencv2/highgui/highgui_c.h"
 
 #include <stdlib.h>
@@ -92,90 +95,6 @@
 #define CV_WINDOW_MAGIC_VAL     0x00420042
 #define CV_TRACKBAR_MAGIC_VAL   0x00420043
 
-/***************************** CvCapture structure ******************************/
-
-struct CvCapture
-{
-    virtual ~CvCapture() {}
-    virtual double getProperty(int) { return 0; }
-    virtual bool setProperty(int, double) { return 0; }
-    virtual bool grabFrame() { return true; }
-    virtual IplImage* retrieveFrame(int) { return 0; }
-    virtual int getCaptureDomain() { return CV_CAP_ANY; } // Return the type of the capture object: CV_CAP_VFW, etc...
-};
-
-/*************************** CvVideoWriter structure ****************************/
-
-struct CvVideoWriter
-{
-    virtual ~CvVideoWriter() {}
-    virtual bool writeFrame(const IplImage*) { return false; }
-};
-
-CvCapture * cvCreateCameraCapture_V4L( int index );
-CvCapture * cvCreateCameraCapture_DC1394( int index );
-CvCapture * cvCreateCameraCapture_DC1394_2( int index );
-CvCapture* cvCreateCameraCapture_MIL( int index );
-CvCapture* cvCreateCameraCapture_Giganetix( int index );
-CvCapture * cvCreateCameraCapture_CMU( int index );
-CV_IMPL CvCapture * cvCreateCameraCapture_TYZX( int index );
-CvCapture* cvCreateFileCapture_Win32( const char* filename );
-CvCapture* cvCreateCameraCapture_VFW( int index );
-CvCapture* cvCreateFileCapture_VFW( const char* filename );
-CvVideoWriter* cvCreateVideoWriter_Win32( const char* filename, int fourcc,
-                                          double fps, CvSize frameSize, int is_color );
-CvVideoWriter* cvCreateVideoWriter_VFW( const char* filename, int fourcc,
-                                        double fps, CvSize frameSize, int is_color );
-CvCapture* cvCreateCameraCapture_DShow( int index );
-CvCapture* cvCreateCameraCapture_MSMF( int index );
-CvCapture* cvCreateFileCapture_MSMF (const char* filename);
-CvVideoWriter* cvCreateVideoWriter_MSMF( const char* filename, int fourcc,
-                                        double fps, CvSize frameSize, int is_color );
-CvCapture* cvCreateCameraCapture_OpenNI( int index );
-CvCapture* cvCreateFileCapture_OpenNI( const char* filename );
-CvCapture* cvCreateCameraCapture_Android( int index );
-CvCapture* cvCreateCameraCapture_XIMEA( int index );
-CvCapture* cvCreateCameraCapture_AVFoundation(int index);
-
-CVAPI(int) cvHaveImageReader(const char* filename);
-CVAPI(int) cvHaveImageWriter(const char* filename);
-
-CvCapture* cvCreateFileCapture_Images(const char* filename);
-CvVideoWriter* cvCreateVideoWriter_Images(const char* filename);
-
-CvCapture* cvCreateFileCapture_XINE (const char* filename);
-
-
-
-
-#define CV_CAP_GSTREAMER_1394		0
-#define CV_CAP_GSTREAMER_V4L		1
-#define CV_CAP_GSTREAMER_V4L2		2
-#define CV_CAP_GSTREAMER_FILE		3
-
-CvCapture* cvCreateCapture_GStreamer(int type, const char *filename);
-CvCapture* cvCreateFileCapture_FFMPEG_proxy(const char* filename);
-
-
-CvVideoWriter* cvCreateVideoWriter_FFMPEG_proxy( const char* filename, int fourcc,
-                                            double fps, CvSize frameSize, int is_color );
-
-CvCapture * cvCreateFileCapture_QT (const char  * filename);
-CvCapture * cvCreateCameraCapture_QT  (const int     index);
-
-CvVideoWriter* cvCreateVideoWriter_QT ( const char* filename, int fourcc,
-                                        double fps, CvSize frameSize, int is_color );
-
-CvCapture* cvCreateFileCapture_AVFoundation (const char * filename);
-CvVideoWriter* cvCreateVideoWriter_AVFoundation( const char* filename, int fourcc,
-                                                double fps, CvSize frameSize, int is_color );
-
-
-CvCapture * cvCreateCameraCapture_Unicap  (const int     index);
-CvCapture * cvCreateCameraCapture_PvAPI  (const int     index);
-CvVideoWriter* cvCreateVideoWriter_GStreamer( const char* filename, int fourcc,
-                                            double fps, CvSize frameSize, int is_color );
-
 //Yannick Verdie 2010
 void cvSetModeWindow_W32(const char* name, double prop_value);
 void cvSetModeWindow_GTK(const char* name, double prop_value);
@@ -196,20 +115,6 @@ double cvGetRatioWindow_GTK(const char* name);
 double cvGetOpenGlProp_W32(const char* name);
 double cvGetOpenGlProp_GTK(const char* name);
 
-namespace cv
-{
-    class IVideoCapture
-    {
-    public:
-        virtual ~IVideoCapture() {}
-        virtual double getProperty(int) { return 0; }
-        virtual bool setProperty(int, double) { return 0; }
-        virtual bool grabFrame() = 0;
-        virtual bool retrieveFrame(int, cv::OutputArray) = 0;
-        virtual int getCaptureDomain() { return CAP_ANY; } // Return the type of the capture object: CAP_VFW, etc...
-    };
-};
-
 //for QT
 #if defined (HAVE_QT)
 double cvGetModeWindow_QT(const char* name);

modules/highgui/test/test_precomp.hpp

@@ -11,80 +11,11 @@
 
 #include <iostream>
 #include "opencv2/ts.hpp"
-#include "opencv2/imgproc.hpp"
+//#include "opencv2/imgproc.hpp"
-#include "opencv2/highgui.hpp"
+//#include "opencv2/imgcodecs.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
+//#include "opencv2/highgui.hpp"
+//#include "opencv2/imgproc/imgproc_c.h"
 
-#include "opencv2/core/private.hpp"
+//#include "opencv2/core/private.hpp"
-
-#if defined(HAVE_DSHOW)        || \
-    defined(HAVE_TYZX)         || \
-    defined(HAVE_VFW)          || \
-    defined(HAVE_LIBV4L)       || \
-    (defined(HAVE_CAMV4L) && defined(HAVE_CAMV4L2)) || \
-    defined(HAVE_GSTREAMER)    || \
-    defined(HAVE_DC1394_2)     || \
-    defined(HAVE_DC1394)       || \
-    defined(HAVE_CMU1394)      || \
-    defined(HAVE_MIL)          || \
-    defined(HAVE_QUICKTIME)    || \
-    defined(HAVE_QTKIT)        || \
-    defined(HAVE_UNICAP)       || \
-    defined(HAVE_PVAPI)        || \
-    defined(HAVE_OPENNI)       || \
-    defined(HAVE_XIMEA)        || \
-    defined(HAVE_AVFOUNDATION) || \
-    defined(HAVE_GIGE_API)     || \
-    defined(HAVE_INTELPERC)    || \
-    (0)
-    //defined(HAVE_ANDROID_NATIVE_CAMERA) ||   - enable after #1193
-#  define BUILD_WITH_CAMERA_SUPPORT 1
-#else
-#  define BUILD_WITH_CAMERA_SUPPORT 0
-#endif
-
-#if defined(HAVE_XINE)         || \
-    defined(HAVE_GSTREAMER)    || \
-    defined(HAVE_QUICKTIME)    || \
-    defined(HAVE_QTKIT)        || \
-    defined(HAVE_AVFOUNDATION) || \
-    /*defined(HAVE_OPENNI)     || too specialized */ \
-    defined(HAVE_FFMPEG)       || \
-    defined(HAVE_MSMF)
-#  define BUILD_WITH_VIDEO_INPUT_SUPPORT 1
-#else
-#  define BUILD_WITH_VIDEO_INPUT_SUPPORT 0
-#endif
-
-#if /*defined(HAVE_XINE)       || */\
-    defined(HAVE_GSTREAMER)    || \
-    defined(HAVE_QUICKTIME)    || \
-    defined(HAVE_QTKIT)        || \
-    defined(HAVE_AVFOUNDATION) || \
-    defined(HAVE_FFMPEG)       || \
-    defined(HAVE_MSMF)
-#  define BUILD_WITH_VIDEO_OUTPUT_SUPPORT 1
-#else
-#  define BUILD_WITH_VIDEO_OUTPUT_SUPPORT 0
-#endif
-
-namespace cvtest
-{
-
-string fourccToString(int fourcc);
-
-struct VideoFormat
-{
-    VideoFormat() { fourcc = -1; }
-    VideoFormat(const string& _ext, int _fourcc) : ext(_ext), fourcc(_fourcc) {}
-    bool empty() const { return ext.empty(); }
-
-    string ext;
-    int fourcc;
-};
-
-extern const VideoFormat g_specific_fmt_list[];
-
-}
 
 #endif

modules/imgcodecs/CMakeLists.txt

@@ -0,0 +1,131 @@
+set(the_description "Image codecs")
+ocv_add_module(imgcodecs opencv_imgproc)
+
+# ----------------------------------------------------------------------------
+#  CMake file for imgcodecs. See root CMakeLists.txt
+#   Some parts taken from version of Hartmut Seichter, HIT Lab NZ.
+#   Jose Luis Blanco, 2008
+# ----------------------------------------------------------------------------
+
+ocv_clear_vars(GRFMT_LIBS)
+
+if(HAVE_WINRT_CX)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /ZW")
+endif()
+
+if(HAVE_PNG OR HAVE_TIFF OR HAVE_OPENEXR)
+  ocv_include_directories(${ZLIB_INCLUDE_DIRS})
+  list(APPEND GRFMT_LIBS ${ZLIB_LIBRARIES})
+endif()
+
+if(HAVE_JPEG)
+  ocv_include_directories(${JPEG_INCLUDE_DIR})
+  list(APPEND GRFMT_LIBS ${JPEG_LIBRARIES})
+endif()
+
+if(WITH_WEBP)
+  add_definitions(-DHAVE_WEBP)
+  ocv_include_directories(${WEBP_INCLUDE_DIR})
+  list(APPEND GRFMT_LIBS ${WEBP_LIBRARIES})
+endif()
+
+if(HAVE_PNG)
+  add_definitions(${PNG_DEFINITIONS})
+  ocv_include_directories(${PNG_INCLUDE_DIR})
+  list(APPEND GRFMT_LIBS ${PNG_LIBRARIES})
+endif()
+
+if(HAVE_TIFF)
+  ocv_include_directories(${TIFF_INCLUDE_DIR})
+  list(APPEND GRFMT_LIBS ${TIFF_LIBRARIES})
+endif()
+
+if(HAVE_JASPER)
+  ocv_include_directories(${JASPER_INCLUDE_DIR})
+  list(APPEND GRFMT_LIBS ${JASPER_LIBRARIES})
+endif()
+
+if(HAVE_OPENEXR)
+  include_directories(SYSTEM ${OPENEXR_INCLUDE_PATHS})
+  list(APPEND GRFMT_LIBS ${OPENEXR_LIBRARIES})
+endif()
+
+file(GLOB grfmt_hdrs src/grfmt*.hpp)
+file(GLOB grfmt_srcs src/grfmt*.cpp)
+list(APPEND grfmt_hdrs src/bitstrm.hpp)
+list(APPEND grfmt_srcs src/bitstrm.cpp)
+list(APPEND grfmt_hdrs src/rgbe.hpp)
+list(APPEND grfmt_srcs src/rgbe.cpp)
+
+source_group("Src\\grfmts" FILES ${grfmt_hdrs} ${grfmt_srcs})
+
+set(imgcodecs_hdrs
+    src/precomp.hpp
+    src/utils.hpp
+    )
+
+set(imgcodecs_srcs
+    src/loadsave.cpp
+    src/utils.cpp
+    )
+
+file(GLOB imgcodecs_ext_hdrs "include/opencv2/*.hpp" "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
+
+if(IOS)
+  add_definitions(-DHAVE_IOS=1)
+  list(APPEND imgcodecs_srcs src/ios_conversions.mm)
+  list(APPEND IMGCODECS_LIBRARIES "-framework Accelerate" "-framework CoreGraphics" "-framework CoreImage" "-framework QuartzCore" "-framework AssetsLibrary")
+endif()
+
+if(UNIX)
+  #these variables are set by CHECK_MODULE macro
+  foreach(P ${IMGCODECS_INCLUDE_DIRS})
+    ocv_include_directories(${P})
+  endforeach()
+
+  foreach(P ${IMGCODECS_LIBRARY_DIRS})
+    link_directories(${P})
+  endforeach()
+endif()
+
+source_group("Src" FILES ${imgcodecs_srcs} ${imgcodecs_hdrs})
+source_group("Include" FILES ${imgcodecs_ext_hdrs})
+ocv_set_module_sources(HEADERS ${imgcodecs_ext_hdrs} SOURCES ${imgcodecs_srcs} ${imgcodecs_hdrs} ${grfmt_srcs} ${grfmt_hdrs})
+ocv_module_include_directories()
+
+ocv_create_module(${GRFMT_LIBS} ${IMGCODECS_LIBRARIES})
+
+if(APPLE)
+  ocv_check_flag_support(OBJCXX "-fobjc-exceptions" HAVE_OBJC_EXCEPTIONS)
+  if(HAVE_OBJC_EXCEPTIONS)
+    foreach(source ${OPENCV_MODULE_${the_module}_SOURCES})
+      if("${source}" MATCHES "\\.mm$")
+        get_source_file_property(flags "${source}" COMPILE_FLAGS)
+        if(flags)
+          set(flags "${_flags} -fobjc-exceptions")
+        else()
+          set(flags "-fobjc-exceptions")
+        endif()
+
+        set_source_files_properties("${source}" PROPERTIES COMPILE_FLAGS "${flags}")
+      endif()
+    endforeach()
+  endif()
+endif()
+
+if(BUILD_SHARED_LIBS)
+  add_definitions(-DIMGCODECS_EXPORTS)
+endif()
+
+if(MSVC)
+  set_target_properties(${the_module} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /NODEFAULTLIB:libcmt.lib /DEBUG")
+endif()
+
+#stop automatic dependencies propagation for this module
+set_target_properties(${the_module} PROPERTIES LINK_INTERFACE_LIBRARIES "")
+
+ocv_add_precompiled_headers(${the_module})
+ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-deprecated-declarations)
+
+ocv_add_accuracy_tests()
+ocv_add_perf_tests()

modules/imgcodecs/doc/imgcodecs.rst

@@ -0,0 +1,10 @@
+*****************************************
+imgcodecs. Image file reading and writing
+*****************************************
+
+This module of the OpenCV help you read and write images to/from disk or memory.
+
+.. toctree::
+    :maxdepth: 2
+
+    reading_and_writing_images

modules/imgcodecs/doc/reading_and_writing_images.rst

@@ -0,0 +1,187 @@
+Reading and Writing Images
+==========================
+
+.. highlight:: cpp
+
+imdecode
+--------
+Reads an image from a buffer in memory.
+
+.. ocv:function:: Mat imdecode( InputArray buf,  int flags )
+
+.. ocv:function:: Mat imdecode( InputArray buf,  int flags, Mat* dst )
+
+.. ocv:cfunction:: IplImage* cvDecodeImage( const CvMat* buf, int iscolor=CV_LOAD_IMAGE_COLOR)
+
+.. ocv:cfunction:: CvMat* cvDecodeImageM( const CvMat* buf, int iscolor=CV_LOAD_IMAGE_COLOR)
+
+.. ocv:pyfunction:: cv2.imdecode(buf, flags) -> retval
+
+    :param buf: Input array or vector of bytes.
+
+    :param flags: The same flags as in :ocv:func:`imread` .
+
+    :param dst: The optional output placeholder for the decoded matrix. It can save the image reallocations when the function is called repeatedly for images of the same size.
+
+The function reads an image from the specified buffer in the memory.
+If the buffer is too short or contains invalid data, the empty matrix/image is returned.
+
+See
+:ocv:func:`imread` for the list of supported formats and flags description.
+
+.. note:: In the case of color images, the decoded images will have the channels stored in ``B G R`` order.
+
+imencode
+--------
+Encodes an image into a memory buffer.
+
+.. ocv:function:: bool imencode( const String& ext, InputArray img, vector<uchar>& buf, const vector<int>& params=vector<int>())
+
+.. ocv:cfunction:: CvMat* cvEncodeImage( const char* ext, const CvArr* image, const int* params=0 )
+
+.. ocv:pyfunction:: cv2.imencode(ext, img[, params]) -> retval, buf
+
+    :param ext: File extension that defines the output format.
+
+    :param img: Image to be written.
+
+    :param buf: Output buffer resized to fit the compressed image.
+
+    :param params: Format-specific parameters. See  :ocv:func:`imwrite` .
+
+The function compresses the image and stores it in the memory buffer that is resized to fit the result.
+See
+:ocv:func:`imwrite` for the list of supported formats and flags description.
+
+.. note:: ``cvEncodeImage`` returns single-row matrix of type ``CV_8UC1`` that contains encoded image as array of bytes.
+
+imread
+------
+Loads an image from a file.
+
+.. ocv:function:: Mat imread( const String& filename, int flags=IMREAD_COLOR )
+
+.. ocv:pyfunction:: cv2.imread(filename[, flags]) -> retval
+
+.. ocv:cfunction:: IplImage* cvLoadImage( const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )
+
+.. ocv:cfunction:: CvMat* cvLoadImageM( const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )
+
+    :param filename: Name of file to be loaded.
+
+    :param flags: Flags specifying the color type of a loaded image:
+
+        * CV_LOAD_IMAGE_ANYDEPTH - If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit.
+
+        * CV_LOAD_IMAGE_COLOR - If set, always convert image to the color one
+
+        * CV_LOAD_IMAGE_GRAYSCALE - If set, always convert image to the grayscale one
+
+        * **>0**  Return a 3-channel color image.
+            .. note:: In the current implementation the alpha channel, if any, is stripped from the output image. Use negative value if you need the alpha channel.
+
+        * **=0**  Return a grayscale image.
+
+        * **<0**  Return the loaded image as is (with alpha channel).
+
+The function ``imread`` loads an image from the specified file and returns it. If the image cannot be read (because of missing file, improper permissions, unsupported or invalid format), the function returns an empty matrix ( ``Mat::data==NULL`` ). Currently, the following file formats are supported:
+
+ * Windows bitmaps - ``*.bmp, *.dib`` (always supported)
+
+ * JPEG files - ``*.jpeg, *.jpg, *.jpe`` (see the *Notes* section)
+
+ * JPEG 2000 files - ``*.jp2`` (see the *Notes* section)
+
+ * Portable Network Graphics - ``*.png`` (see the *Notes* section)
+
+ * WebP - ``*.webp`` (see the *Notes* section)
+
+ * Portable image format - ``*.pbm, *.pgm, *.ppm``     (always supported)
+
+ * Sun rasters - ``*.sr, *.ras``     (always supported)
+
+ * TIFF files - ``*.tiff, *.tif`` (see the *Notes* section)
+
+.. note::
+
+    * The function determines the type of an image by the content, not by the file extension.
+
+    * On Microsoft Windows* OS and MacOSX*, the codecs shipped with an OpenCV image (libjpeg, libpng, libtiff, and libjasper) are used by default. So, OpenCV can always read JPEGs, PNGs, and TIFFs. On MacOSX, there is also an option to use native MacOSX image readers. But beware that currently these native image loaders give images with different pixel values because of the color management embedded into MacOSX.
+
+    * On Linux*, BSD flavors and other Unix-like open-source operating systems, OpenCV looks for codecs supplied with an OS image. Install the relevant packages (do not forget the development files, for example, "libjpeg-dev", in Debian* and Ubuntu*) to get the codec support or turn on the ``OPENCV_BUILD_3RDPARTY_LIBS`` flag in CMake.
+
+.. note:: In the case of color images, the decoded images will have the channels stored in ``B G R`` order.
+
+imwrite
+-----------
+Saves an image to a specified file.
+
+.. ocv:function:: bool imwrite( const String& filename, InputArray img, const vector<int>& params=vector<int>() )
+
+.. ocv:pyfunction:: cv2.imwrite(filename, img[, params]) -> retval
+
+.. ocv:cfunction:: int cvSaveImage( const char* filename, const CvArr* image, const int* params=0 )
+
+    :param filename: Name of the file.
+
+    :param image: Image to be saved.
+
+    :param params: Format-specific save parameters encoded as pairs  ``paramId_1, paramValue_1, paramId_2, paramValue_2, ...`` . The following parameters are currently supported:
+
+        *  For JPEG, it can be a quality ( ``CV_IMWRITE_JPEG_QUALITY`` ) from 0 to 100 (the higher is the better). Default value is 95.
+
+        *  For WEBP, it can be a quality ( CV_IMWRITE_WEBP_QUALITY ) from 1 to 100 (the higher is the better).
+           By default (without any parameter) and for quality above 100 the lossless compression is used.
+
+        *  For PNG, it can be the compression level ( ``CV_IMWRITE_PNG_COMPRESSION`` ) from 0 to 9. A higher value means a smaller size and longer compression time. Default value is 3.
+
+        *  For PPM, PGM, or PBM, it can be a binary format flag ( ``CV_IMWRITE_PXM_BINARY`` ), 0 or 1. Default value is 1.
+
+The function ``imwrite`` saves the image to the specified file. The image format is chosen based on the ``filename`` extension (see
+:ocv:func:`imread` for the list of extensions). Only 8-bit (or 16-bit unsigned (``CV_16U``) in case of PNG, JPEG 2000, and TIFF) single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function. If the format, depth or channel order is different, use
+:ocv:func:`Mat::convertTo` , and
+:ocv:func:`cvtColor` to convert it before saving. Or, use the universal :ocv:class:`FileStorage` I/O functions to save the image to XML or YAML format.
+
+It is possible to store PNG images with an alpha channel using this function. To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha channel goes last. Fully transparent pixels should have alpha set to 0, fully opaque pixels should have alpha set to 255/65535. The sample below shows how to create such a BGRA image and store to PNG file. It also demonstrates how to set custom compression parameters ::
+
+    #include <vector>
+    #include <stdio.h>
+    #include <opencv2/opencv.hpp>
+
+    using namespace cv;
+    using namespace std;
+
+    void createAlphaMat(Mat &mat)
+    {
+        for (int i = 0; i < mat.rows; ++i) {
+            for (int j = 0; j < mat.cols; ++j) {
+                Vec4b& rgba = mat.at<Vec4b>(i, j);
+                rgba[0] = UCHAR_MAX;
+                rgba[1] = saturate_cast<uchar>((float (mat.cols - j)) / ((float)mat.cols) * UCHAR_MAX);
+                rgba[2] = saturate_cast<uchar>((float (mat.rows - i)) / ((float)mat.rows) * UCHAR_MAX);
+                rgba[3] = saturate_cast<uchar>(0.5 * (rgba[1] + rgba[2]));
+            }
+        }
+    }
+
+    int main(int argv, char **argc)
+    {
+        // Create mat with alpha channel
+        Mat mat(480, 640, CV_8UC4);
+        createAlphaMat(mat);
+
+        vector<int> compression_params;
+        compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);
+        compression_params.push_back(9);
+
+        try {
+            imwrite("alpha.png", mat, compression_params);
+        }
+        catch (runtime_error& ex) {
+            fprintf(stderr, "Exception converting image to PNG format: %s\n", ex.what());
+            return 1;
+        }
+
+        fprintf(stdout, "Saved PNG file with alpha data.\n");
+        return 0;
+    }

modules/imgcodecs/include/opencv2/imgcodecs.hpp

@@ -0,0 +1,91 @@
+/*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, 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_IMGCODECS_HPP__
+#define __OPENCV_IMGCODECS_HPP__
+
+#include "opencv2/core.hpp"
+
+//////////////////////////////// image codec ////////////////////////////////
+namespace cv
+{
+
+enum { IMREAD_UNCHANGED  = -1, // 8bit, color or not
+       IMREAD_GRAYSCALE  = 0,  // 8bit, gray
+       IMREAD_COLOR      = 1,  // ?, color
+       IMREAD_ANYDEPTH   = 2,  // any depth, ?
+       IMREAD_ANYCOLOR   = 4   // ?, any color
+     };
+
+enum { IMWRITE_JPEG_QUALITY     = 1,
+       IMWRITE_JPEG_PROGRESSIVE = 2,
+       IMWRITE_JPEG_OPTIMIZE    = 3,
+       IMWRITE_PNG_COMPRESSION  = 16,
+       IMWRITE_PNG_STRATEGY     = 17,
+       IMWRITE_PNG_BILEVEL      = 18,
+       IMWRITE_PXM_BINARY       = 32,
+       IMWRITE_WEBP_QUALITY     = 64
+     };
+
+enum { IMWRITE_PNG_STRATEGY_DEFAULT      = 0,
+       IMWRITE_PNG_STRATEGY_FILTERED     = 1,
+       IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2,
+       IMWRITE_PNG_STRATEGY_RLE          = 3,
+       IMWRITE_PNG_STRATEGY_FIXED        = 4
+     };
+
+CV_EXPORTS_W Mat imread( const String& filename, int flags = IMREAD_COLOR );
+
+CV_EXPORTS_W bool imwrite( const String& filename, InputArray img,
+              const std::vector<int>& params = std::vector<int>());
+
+CV_EXPORTS_W Mat imdecode( InputArray buf, int flags );
+
+CV_EXPORTS Mat imdecode( InputArray buf, int flags, Mat* dst);
+
+CV_EXPORTS_W bool imencode( const String& ext, InputArray img,
+                            CV_OUT std::vector<uchar>& buf,
+                            const std::vector<int>& params = std::vector<int>());
+
+} // cv
+
+#endif //__OPENCV_IMGCODECS_HPP__

modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs.hpp

@@ -0,0 +1,48 @@
+/*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, Willow Garage Inc., all rights reserved.
+// 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.
+//
+//M*/
+
+#ifdef __OPENCV_BUILD
+#error this is a compatibility header which should not be used inside the OpenCV library
+#endif
+
+#include "opencv2/imgcodecs.hpp"

modules/imgcodecs/include/opencv2/imgcodecs/imgcodecs_c.h

@@ -0,0 +1,129 @@
+/*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.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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_IMGCODECS_H__
+#define __OPENCV_IMGCODECS_H__
+
+#include "opencv2/core/core_c.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+enum
+{
+/* 8bit, color or not */
+    CV_LOAD_IMAGE_UNCHANGED  =-1,
+/* 8bit, gray */
+    CV_LOAD_IMAGE_GRAYSCALE  =0,
+/* ?, color */
+    CV_LOAD_IMAGE_COLOR      =1,
+/* any depth, ? */
+    CV_LOAD_IMAGE_ANYDEPTH   =2,
+/* ?, any color */
+    CV_LOAD_IMAGE_ANYCOLOR   =4
+};
+
+/* load image from file
+  iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
+  overrides the other flags
+  using CV_LOAD_IMAGE_ANYCOLOR alone is equivalent to CV_LOAD_IMAGE_UNCHANGED
+  unless CV_LOAD_IMAGE_ANYDEPTH is specified images are converted to 8bit
+*/
+CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
+CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
+
+enum
+{
+    CV_IMWRITE_JPEG_QUALITY =1,
+    CV_IMWRITE_JPEG_PROGRESSIVE =2,
+    CV_IMWRITE_JPEG_OPTIMIZE =3,
+    CV_IMWRITE_PNG_COMPRESSION =16,
+    CV_IMWRITE_PNG_STRATEGY =17,
+    CV_IMWRITE_PNG_BILEVEL =18,
+    CV_IMWRITE_PNG_STRATEGY_DEFAULT =0,
+    CV_IMWRITE_PNG_STRATEGY_FILTERED =1,
+    CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY =2,
+    CV_IMWRITE_PNG_STRATEGY_RLE =3,
+    CV_IMWRITE_PNG_STRATEGY_FIXED =4,
+    CV_IMWRITE_PXM_BINARY =32,
+    CV_IMWRITE_WEBP_QUALITY =64
+};
+
+/* save image to file */
+CVAPI(int) cvSaveImage( const char* filename, const CvArr* image,
+                        const int* params CV_DEFAULT(0) );
+
+/* decode image stored in the buffer */
+CVAPI(IplImage*) cvDecodeImage( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
+CVAPI(CvMat*) cvDecodeImageM( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
+
+/* encode image and store the result as a byte vector (single-row 8uC1 matrix) */
+CVAPI(CvMat*) cvEncodeImage( const char* ext, const CvArr* image,
+                             const int* params CV_DEFAULT(0) );
+
+enum
+{
+    CV_CVTIMG_FLIP      =1,
+    CV_CVTIMG_SWAP_RB   =2
+};
+
+/* utility function: convert one image to another with optional vertical flip */
+CVAPI(void) cvConvertImage( const CvArr* src, CvArr* dst, int flags CV_DEFAULT(0));
+
+CVAPI(int) cvHaveImageReader(const char* filename);
+CVAPI(int) cvHaveImageWriter(const char* filename);
+
+
+/****************************************************************************************\
+*                              Obsolete functions/synonyms                               *
+\****************************************************************************************/
+
+#define cvvLoadImage(name) cvLoadImage((name),1)
+#define cvvSaveImage cvSaveImage
+#define cvvConvertImage cvConvertImage
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __OPENCV_IMGCODECS_H__

modules/imgcodecs/include/opencv2/imgcodecs/ios.h

@@ -41,8 +41,11 @@
 //
 //M*/
 
+#import <UIKit/UIKit.h>
+#import <Accelerate/Accelerate.h>
+#import <AVFoundation/AVFoundation.h>
+#import <ImageIO/ImageIO.h>
 #include "opencv2/core/core.hpp"
-#import "opencv2/highgui/cap_ios.h"
 
 UIImage* MatToUIImage(const cv::Mat& image);
 void UIImageToMat(const UIImage* image,

modules/imgcodecs/perf/perf_main.cpp

@@ -0,0 +1,3 @@
+#include "perf_precomp.hpp"
+
+CV_PERF_TEST_MAIN(imgcodecs)

modules/imgcodecs/perf/perf_precomp.hpp

@@ -0,0 +1,19 @@
+#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__
+
+#include "opencv2/ts.hpp"
+#include "opencv2/imgcodecs.hpp"
+
+#ifdef GTEST_CREATE_SHARED_LIBRARY
+#error no modules except ts should have GTEST_CREATE_SHARED_LIBRARY defined
+#endif
+
+#endif